daisyui 2.1.0 → 2.2.0

data/lib/daisy_ui/tailwind/sources.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+module DaisyUI
+  module Tailwind
+    # Renders the Tailwind sources for a set of (resolved) components:
+    #
+    # - `to_css`: a partial for the app's Tailwind entry to @import, one
+    #   `@source inline("…")` per component after base.rb's shared classes. It
+    #   names no path, so it is the same on every machine.
+    # - `to_json`: the same for a build script, plus each component's absolute
+    #   files for anyone who wants a literal `@source` instead.
+    #
+    # `responsive:` adds `<breakpoint>:` variants of the classes `responsive:`
+    # renders (a component's own class and its modifiers). `prefix:` mirrors
+    # DaisyUI.configuration.prefix: the component class and modifiers always
+    # render prefixed, while a class string in a component's Ruby may render
+    # either way (`component_classes("card-body")` is prefixed, Tooltip's
+    # "after:hidden" is not), so those are given both ways.
+    class Sources
+      BREAKPOINT = /\A@?[a-z0-9][a-z0-9-]*\z/
+      PREFIX = /\A[^\s"'`;{}\\]+\z/
+
+      attr_reader :components
+
+      # @api private Shared with AppSources.
+      def self.validate_options!(breakpoints, prefix)
+        breakpoints.each do |breakpoint|
+          raise ArgumentError, "invalid breakpoint #{breakpoint.inspect}: give the variant name, e.g. sm or @md" unless BREAKPOINT.match?(breakpoint)
+        end
+        return if prefix.empty? || PREFIX.match?(prefix)
+
+        raise ArgumentError, "invalid prefix #{prefix.inspect}"
+      end
+
+      def initialize(manifest, components, responsive: [], prefix: nil)
+        @manifest = manifest
+        @components = components
+        @breakpoints = responsive.map(&:to_s)
+        @prefix = prefix.to_s
+        validate!
+      end
+
+      def render(format)
+        case format.to_s
+        when "css" then to_css
+        when "json" then to_json
+        else raise ArgumentError, "unknown format #{format.inspect}: css or json"
+        end
+      end
+
+      def to_css
+        header = "/* Generated by daisyui-tailwind (daisyui #{VERSION}): do not edit. */\n"
+        return "#{header}/* No DaisyUI components referenced. */\n" if components.empty?
+
+        lines = [
+          "/* daisyUI components: #{components.join(', ')} */",
+          "/* Shared by every component (lib/daisy_ui/base.rb) */",
+          inline(shared_classes)
+        ]
+        components.each { |name| lines.push("/* #{@manifest.components.fetch(name)['class']} */", inline(classes(name))) }
+        "#{header}#{lines.join("\n")}\n"
+      end
+
+      def to_json(*)
+        require "json"
+
+        "#{JSON.pretty_generate(json)}\n"
+      end
+
+      private
+
+      def json
+        files = @manifest.shared_files + @manifest.files(components)
+        {
+          "daisyui" => VERSION,
+          "components" => components.to_h { |name| [name, component_json(name)] },
+          "shared" => { "files" => @manifest.shared_files, "classes" => shared_classes },
+          "classes" => (shared_classes + components.flat_map { |name| classes(name) }).uniq.sort,
+          "files" => files.uniq.sort
+        }
+      end
+
+      def component_json(name)
+        entry = @manifest.components.fetch(name)
+        entry.slice("class", "name", "depends_on").merge("files" => @manifest.files([name]), "classes" => classes(name))
+      end
+
+      def classes(name)
+        entry = @manifest.components.fetch(name)
+        expand(entry["classes"], [entry["name"], *entry["modifiers"]].compact)
+      end
+
+      def shared_classes = expand(@manifest.shared["classes"], @manifest.shared["classes"])
+
+      def expand(classes, responsive)
+        prefixed = classes.map { |token| "#{@prefix}#{token}" }
+        prefixed += classes - responsive unless @prefix.empty?
+        prefixed + @breakpoints.flat_map { |breakpoint| responsive.map { |token| "#{breakpoint}:#{@prefix}#{token}" } }
+      end
+
+      def inline(classes) = %(@source inline("#{classes.join(' ')}");)
+
+      def validate! = self.class.validate_options!(@breakpoints, @prefix)
+    end
+  end
+end

data/lib/daisy_ui/tailwind/unknown_component_error.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require "did_you_mean"
+
+module DaisyUI
+  module Tailwind
+    # A component name (`--component Buton`) the manifest does not have.
+    class UnknownComponentError < ArgumentError
+      def initialize(name, known)
+        suggestions = DidYouMean::SpellChecker.new(dictionary: known).correct(name.to_s)
+        message = "DaisyUI has no component #{name}"
+        message = "#{message}. Did you mean? #{suggestions.join(', ')}" unless suggestions.empty?
+        super(message)
+      end
+    end
+  end
+end

data/lib/daisy_ui/tailwind/usage.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module DaisyUI
+  module Tailwind
+    # Finds the components an app's Ruby and templates reference:
+    #
+    # - the constant: `DaisyUI::Card`, `class AppNavbar < DaisyUI::Navbar`
+    # - an instance: `Card.new(…)`
+    # - a kit call, with parentheses (`Button(:primary)`) or without
+    #   (`Badge :primary do`, `Hero do`, `Modal { … }`, `Toast class: "…"`,
+    #   `Button variant do`)
+    #
+    # Comments are skipped (each file's own kind: `#` lines in Ruby, `<%# %>`
+    # in ERB, `-#` in HAML, `/` in Slim), so "# Loading state…" is not a use
+    # of Loading, while a HAML `#sidebar= …` line still counts. A name is matched whole: `MyButton(` and `UI::Card(` are not
+    # uses (an app wrapper `UI::Card < DaisyUI::Card` is found by its own
+    # file). Matching on text over-reports rather than misses: a false hit
+    # costs some CSS, a miss leaves a component unstyled.
+    class Usage
+      COMMENTS = {
+        "rb" => /^[ \t]*#.*$/,
+        "erb" => /<%#.*?%>/m,
+        "haml" => /^[ \t]*-#.*$/,
+        "slim" => %r{^[ \t]*/.*$}
+      }.freeze
+      EXTENSIONS = COMMENTS.keys.freeze
+      # What follows a name in a call: `(`, `.new`, a block, or arguments
+      # without parentheses: `:primary`, `class: …`, `"…"`, a splat
+      # (`*modifiers`, `**options`, `&block`), or a variable that ends the line
+      # or is followed by `,`, `do` or `{` (`Button variant do`), which keeps
+      # "Join thousands of…" in a string from counting.
+      CALL = /
+        \( | \.new\b | [ \t]*\{ |
+        [ \t]+ (?: do\b | :[a-z_] | ["'] | [a-z_]\w*:[ \t] | (?: \*\*? | & ) [a-z_@(] |
+                  [a-z_@][\w@]* (?: \.[a-z_]\w* )* [ \t]* (?: , | do\b | \{ | $ ) )
+      /x
+
+      def initialize(names)
+        names = names.sort_by { |name| -name.length }.map { |name| Regexp.escape(name) }.join("|")
+        @pattern = /DaisyUI::(#{names})\b|(?<![A-Za-z0-9_:])(#{names})(?=#{CALL})/
+      end
+
+      # Sorted names referenced in the files under `paths` (directories or
+      # files). A path that does not exist raises: a typo must not quietly
+      # leave every component out.
+      def scan(paths)
+        files(paths).flat_map { |file| references(File.read(file).scrub, kind: File.extname(file).delete_prefix(".")) }
+          .uniq.sort
+      end
+
+      # Sorted names referenced in `source`, a file of `kind` (its extension).
+      def references(source, kind: "rb")
+        source.gsub(COMMENTS.fetch(kind, COMMENTS["rb"]), "").scan(@pattern).flat_map(&:compact).uniq.sort
+      end
+
+      private
+
+      def files(paths)
+        paths.flat_map do |path|
+          path = path.to_s
+          if File.directory?(path)
+            Dir.glob(File.join(path, "**", "*.{#{EXTENSIONS.join(',')}}"))
+          elsif File.file?(path)
+            [path]
+          else
+            raise ArgumentError, "no such file or directory: #{path}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/daisy_ui/tailwind.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module DaisyUI
+  # Tailwind CSS sources for only the daisyUI components an app renders.
+  #
+  # Pointing Tailwind's `@source` at the whole gem hands it every class of
+  # every component (and ClassMerge's catalogue of Tailwind utilities), yet
+  # still misses what Tailwind v4 cannot see in Ruby: a Symbol component class
+  # (`self.component_class = :btn`) and anything in a comment. The gem's
+  # manifest (data/daisyui/tailwind_manifest.json, built from the components by
+  # `rake tailwind:manifest`) lists each component's classes and the
+  # components it renders, so an app's CSS build gets `@source inline(…)` for
+  # just the components it uses:
+  #
+  #   DaisyUI::Tailwind.sources(scan: ["app/views", "app/components"])
+  #   DaisyUI::Tailwind.sources(components: %w[Button Navbar], format: :json)
+  #
+  # `bundle exec daisyui-tailwind` (DaisyUI::Tailwind::Command) does the same
+  # from a build script.
+  module Tailwind
+    ROOT = File.expand_path("../..", __dir__).freeze
+    # In the gem's data/ dir, not lib/: an app that still points Tailwind at
+    # the gem's lib/ must not start scanning it.
+    MANIFEST_PATH = File.join(ROOT, "data", "daisyui", "tailwind_manifest.json").freeze
+
+    class << self
+      def manifest = Manifest.load
+
+      # The components the Ruby and templates under `scan` reference, plus the
+      # `components` named, plus every component those render. Sorted names.
+      def used_components(scan: [], components: [], manifest: self.manifest)
+        found = scan.empty? ? [] : Usage.new(manifest.component_names).scan(scan)
+        manifest.resolve(found + components)
+      end
+
+      # CSS (`format: :css`, for Tailwind to @import) or JSON for those
+      # components. `responsive:` adds breakpoint variants (`%w[sm md]`) of the
+      # classes `responsive:` renders; `prefix:` defaults to the
+      # DaisyUI.configuration.prefix the components render with.
+      #
+      # `app: true` gives the app's own components instead (app_components),
+      # or `app: [Widget, …]` the ones named: see AppSources. Their file is
+      # separate from the gem components' and meant to be committed.
+      def sources(scan: [], components: [], app: false, format: :css, responsive: [], prefix: DaisyUI.configuration.prefix)
+        return app_sources(app, scan:, components:).new(app == true ? app_components : app, responsive:, prefix:).render(format) if app
+
+        manifest = self.manifest
+        used = used_components(scan:, components:, manifest:)
+        Sources.new(manifest, used, responsive:, prefix:).render(format)
+      end
+
+      # The app's DaisyUI::Base subclasses, sorted by name: every named one
+      # whose constant still names it (a class a code reload replaced is
+      # skipped), defined outside the gem's lib/ or a gem component the app
+      # reopened to declare variants (the gem's own never do). A Rails app is
+      # eager-loaded first.
+      def app_components
+        ::Rails.application.eager_load! if defined?(::Rails) && ::Rails.respond_to?(:application) && ::Rails.application
+        ClassMerge::DaisyGroups.components.select { |component| current?(component) && app_owned?(component) }.sort_by(&:name)
+      end
+
+      # Whether the committed app sources at `path` differ from what the
+      # declarations give now (or the file is missing): a spec can fail on it,
+      # the way the gem's own manifest spec does.
+      def stale?(path, app: true, **)
+        !File.file?(path) || File.read(path) != sources(app:, **)
+      end
+
+      private
+
+      def app_sources(app, scan:, components:)
+        return AppSources if scan.empty? && components.empty?
+
+        raise ArgumentError, "app: gives the app's own components, a file of its own; " \
+                             "scan: and components: give the gem's (#{app.inspect} with #{(scan + components).inspect})"
+      end
+
+      def app_owned?(component)
+        return true unless Object.const_source_location(component.name)&.first.to_s.start_with?(File.join(ROOT, "lib", ""))
+
+        !component.variant_definitions.equal?(Variants::EMPTY)
+      end
+
+      def current?(component)
+        Object.const_get(component.name).equal?(component)
+      rescue NameError
+        false
+      end
+    end
+  end
+end

data/lib/daisy_ui/unknown_modifier_error.rb

@@ -23,9 +23,16 @@ module DaisyUI
       name = "#{name}##{part}" if part
       message = "#{name} has no modifier #{modifier.inspect}"
       suggestions = DidYouMean::SpellChecker.new(dictionary: known.map(&:to_s)).correct(modifier.to_s)
-      return message if suggestions.empty?
+      message = "#{message}. Did you mean? #{suggestions.map { |s| ":#{s}" }.join(', ')}" unless suggestions.empty?
+      groups.empty? ? message : "#{message}. Variants: #{groups}"
+    end
+
+    # The component's groups and their members, "size: sm, lg; color: …";
+    # a sub-component part has modifiers of its own, so none for it.
+    def groups
+      return "" if part || !component.respond_to?(:modifier_groups)
 
-      "#{message}. Did you mean? #{suggestions.map { |s| ":#{s}" }.join(', ')}"
+      component.modifier_groups.map { |group, members| "#{group}: #{members.join(', ')}" }.join("; ")
     end
   end
 end

data/lib/daisy_ui/updated_at.rb

@@ -3,5 +3,5 @@
 module DaisyUI
   # This timestamp is automatically updated when releasing a new version
   # Format: YYYY-MM-DD HH:MM:SS UTC
-  UPDATED_AT = "2026-10-15 20:45:37 UTC"
+  UPDATED_AT = "2026-10-26 18:45:50 UTC"
 end

data/lib/daisy_ui/variants/match.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module DaisyUI
+  class Variants
+    # What a `compound` or `on` match means, and the checks that make a typo
+    # fail where it is declared (at boot) rather than never match:
+    #
+    # | value            | matches when                                        |
+    # |------------------|-----------------------------------------------------|
+    # | `:member`        | that member is selected (given, defaulted or set)   |
+    # | `[:a, :b]`       | any of them is; a `nil` in the list means "or none" |
+    # | `nil` / `false`  | no member of that group is                          |
+    # | `true`           | any member of that group is                         |
+    # | `true` / `false` | a flag is on / off                                  |
+    #
+    # @api private
+    class Match
+      def initialize(klass)
+        @klass = klass
+      end
+
+      # `selection` is { group => member or nil }, `on` the flags given.
+      def self.holds?(match, selection, on)
+        match.all? do |key, value|
+          if selection.key?(key)
+            member = selection[key]
+            case value
+            when true then !member.nil?
+            when false, nil then member.nil?
+            when Array then value.include?(member)
+            else member == value
+            end
+          else
+            on.include?(key) == value
+          end
+        end
+      end
+
+      def match!(match)
+        match.each do |key, value|
+          if groups.key?(key)
+            value_members(value).each { |member| member!(key, member) }
+          elsif flags.include?(key)
+            raise ArgumentError, "#{owner}: flag #{key.inspect} matches true or false, got #{value.inspect}" unless BOOLS.include?(value)
+          else
+            raise ArgumentError, "#{owner} has no variant or flag #{key.inspect}"
+          end
+        end
+      end
+
+      def member!(group, member)
+        raise ArgumentError, "#{owner} has no variant #{group.inspect}" unless groups.key?(group)
+        return if groups[group].include?(member)
+
+        raise ArgumentError, "#{owner}: #{group.inspect} has no member #{member.inspect}; #{group}: #{groups[group].join(', ')}"
+      end
+
+      def state!(name)
+        return if @klass.variant_definitions[:states].key?(name)
+
+        raise ArgumentError, "#{owner} has no state #{name.inspect}: declare it with `state #{name.inspect}, \"<variant>\"` first"
+      end
+
+      def slot!(name)
+        return if name == :root || @klass.variant_definitions[:slots].key?(name)
+
+        raise ArgumentError, "#{owner} has no slot #{name.inspect}: declare it with `slot #{name.inspect}` first"
+      end
+
+      private
+
+      BOOLS = [true, false].freeze
+      private_constant :BOOLS
+
+      def value_members(value)
+        return [] if value.nil? || value == true || value == false
+
+        Array(value).compact
+      end
+
+      def groups = @klass.modifier_groups
+
+      # Ungrouped modifiers and registered flags.
+      def flags = Schema.flags(@klass)
+
+      def owner = @klass.name || @klass.inspect
+    end
+  end
+end

data/lib/daisy_ui/variants/rendering.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module DaisyUI
+  class Variants
+    # The instance side of the Variants API, included in DaisyUI::Base. A
+    # component without declarations (every gem component) skips it all.
+    module Rendering
+      private
+
+      # The `base` classes a `variants` block declared.
+      def variant_base_classes
+        apply_prefix(self.class.variant_definitions[:base])
+      end
+
+      # For `slot` (:root is the component itself): the classes of the
+      # members a default or compound selected (the root's given members are
+      # modifier_classes already), of every compound that holds, and of every
+      # `on` rule that holds, prefixed with its states.
+      def variant_classes(slot = :root)
+        definitions = self.class.variant_definitions
+        return [] if definitions.equal?(EMPTY)
+
+        resolution = variant_resolution
+        [
+          *variant_member_classes(resolution, slot, definitions),
+          *resolution.compounds.map { |compound| apply_prefix(compound[:class][slot]) },
+          *resolution.rules.flat_map { |rule| state_classes(rule, slot, definitions[:states]) }
+        ].compact
+      end
+
+      # Classes for one of the component's parts: the slot's own, those its
+      # variants, compounds and `on` rules give it, then `options[:class]`
+      # (removed from `options`, as component_classes does).
+      def slot_classes(name, options = self.options)
+        slots = self.class.variant_definitions[:slots]
+        raise ArgumentError, "#{self.class.name || self.class.inspect} has no slot #{name.inspect}" unless slots.key?(name)
+
+        merge_classes(apply_prefix(slots[name]), *variant_classes(name), options.delete(:class))
+      end
+
+      # `options` with the slot's classes, to splat into the part.
+      def slot_options(name, options = self.options)
+        classes = slot_classes(name, options)
+        classes ? options.merge(class: classes) : options
+      end
+
+      def variant_resolution
+        @variant_resolution ||= Resolution.new(self.class, modifiers)
+      end
+
+      def variant_member_classes(resolution, slot, definitions)
+        if slot == :root
+          resolution.implied_members.map { |member| apply_prefix(modifier_map[member]) }
+        else
+          resolution.active.map { |member| apply_prefix(definitions[:slot_classes].dig(member, slot)) }
+        end
+      end
+
+      def state_classes(rule, slot, states)
+        return [] unless (classes = rule[:class][slot])
+
+        rule[:states].flat_map do |state|
+          classes.split.map { |token| "#{states.fetch(state)}:#{apply_prefix(token)}" }
+        end
+      end
+    end
+  end
+end

data/lib/daisy_ui/variants/resolution.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module DaisyUI
+  class Variants
+    # Which members, compounds and `on` rules hold for one instance, worked
+    # out explicitly rather than left to ClassMerge, so a default or a set
+    # member never renders beside the member the caller gave, with class
+    # merging on or off:
+    #
+    # 1. the caller's members (the last one per group, as ClassMerge keeps)
+    # 2. defaults, for groups the caller left empty
+    # 3. compounds in declaration order; each one's `set` fills or replaces a
+    #    member the caller did not name, and later compounds see it
+    # 4. `on` rules, against the final selection
+    #
+    # @api private
+    class Resolution
+      attr_reader :compounds, :rules
+
+      def initialize(klass, given)
+        definitions = klass.variant_definitions
+        @given = given
+        @selection = klass.modifier_groups.to_h { |group, members| [group, given.reverse.find { |m| members.include?(m) }] }
+        @named = @selection.compact.keys
+        definitions[:defaults].each { |group, member| @selection[group] ||= member }
+        @compounds = matching_compounds(definitions[:compounds])
+        @rules = definitions[:rules].select { |rule| holds?(rule[:match]) }
+      end
+
+      # Members a default or a compound selected, not the caller.
+      def implied_members
+        @selection.filter_map { |group, member| member unless @named.include?(group) }
+      end
+
+      # Every member and flag in effect, for the slots' per-member classes.
+      def active = (@given | implied_members)
+
+      private
+
+      # One at a time: a compound's `set` is seen by the compounds after it.
+      def matching_compounds(compounds)
+        compounds.each_with_object([]) do |compound, matched|
+          next unless holds?(compound[:match])
+
+          matched << compound
+          compound[:set].each { |group, member| @selection[group] = member unless @named.include?(group) }
+        end
+      end
+
+      def holds?(match) = Match.holds?(match, @selection, @given)
+    end
+  end
+end

data/lib/daisy_ui/variants/schema.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module DaisyUI
+  class Variants
+    # `Component.variants.schema`: a component's declarations as plain,
+    # frozen data. A component that only calls `register_modifiers` gets its
+    # variants and flags, with the rest empty.
+    #
+    # @api private
+    class Schema
+      # Ungrouped modifiers and the flags registered without a class.
+      def self.flags(klass)
+        grouped = klass.modifier_groups.values.flatten
+        ((klass.modifiers || {}).keys - grouped) | klass.flags
+      end
+
+      def initialize(klass)
+        @klass = klass
+        @definitions = klass.variant_definitions
+      end
+
+      def to_h
+        Shareable.share(
+          base:,
+          variants: @klass.modifier_groups.transform_values(&:dup),
+          flags: self.class.flags(@klass),
+          defaults: @definitions[:defaults].dup,
+          compounds: @definitions[:compounds].map { |entry| { match: entry[:match], class: shown(entry[:class]), set: entry[:set] } },
+          on: @definitions[:rules].map { |entry| { states: entry[:states], match: entry[:match], class: shown(entry[:class]) } },
+          states: @definitions[:states].dup,
+          slots: { root: base, **@definitions[:slots] }
+        )
+      end
+
+      # Every class token the declarations can render, `prefix` included the
+      # way Base#apply_prefix adds it (after any state), sorted.
+      def literal_classes(prefix)
+        plain = [base, *modifier_classes, *@definitions[:slots].values, *slot_member_classes, *compound_classes]
+        plain = plain.compact.flat_map(&:split).map { |token| "#{prefix}#{token}" }
+        (plain + state_classes(prefix)).uniq.sort
+      end
+
+      private
+
+      def base
+        classes = [@klass.component_class&.to_s, @definitions[:base]].compact.join(" ")
+        classes.empty? ? nil : classes
+      end
+
+      def modifier_classes = (@klass.modifiers || {}).values
+
+      def slot_member_classes = @definitions[:slot_classes].values.flat_map(&:values)
+
+      def compound_classes = @definitions[:compounds].flat_map { |entry| entry[:class].values }
+
+      def state_classes(prefix)
+        @definitions[:rules].flat_map do |rule|
+          tokens = rule[:class].values.flat_map(&:split)
+          rule[:states].flat_map do |state|
+            tokens.map { |token| "#{@definitions[:states].fetch(state)}:#{prefix}#{token}" }
+          end
+        end
+      end
+
+      # A root-only class shows as its String, per-slot classes as the Hash.
+      def shown(classes)
+        return nil if classes.empty?
+
+        classes.keys == [:root] ? classes[:root] : classes
+      end
+    end
+  end
+end