daisyui 2.1.0 → 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/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

data/lib/daisy_ui/tailwind/command.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module DaisyUI
+  module Tailwind
+    # `daisyui-tailwind`: the Tailwind sources for the components an app uses,
+    # for its CSS build to call (`bundle exec daisyui-tailwind app -o …`).
+    # Returns the exit status; usage errors print to `err` and return 1.
+    class Command
+      BANNER = <<~TEXT
+        Usage: daisyui-tailwind [options] [PATH...]
+
+        Prints Tailwind CSS v4 sources (@source inline) for the DaisyUI components
+        that the Ruby and templates under each PATH use, plus the components those
+        render. @import the output from your Tailwind entry.
+
+      TEXT
+
+      def self.run(argv, out: $stdout, err: $stderr) = new(out:, err:).run(argv)
+
+      def initialize(out:, err:)
+        @out = out
+        @err = err
+      end
+
+      def run(argv)
+        require "optparse"
+
+        options = { components: [], format: "css", responsive: [] }
+        parser = parser(options)
+        paths = parser.parse(argv)
+        return help(parser) if options[:help]
+        return usage(parser) if paths.empty? && options[:components].empty?
+
+        result = Tailwind.sources(scan: paths, **options.slice(:components, :format, :responsive, :prefix))
+        options[:output] ? write(options[:output], result) : @out.write(result)
+        0
+      rescue OptionParser::ParseError, ArgumentError, SystemCallError => e
+        @err.puts "daisyui-tailwind: #{e.message}"
+        1
+      end
+
+      private
+
+      def parser(options)
+        OptionParser.new do |opts|
+          opts.banner = BANNER
+          opts.on("-c", "--component NAMES", Array, "Components to include, e.g. Button,Navbar (repeatable)") do |names|
+            options[:components].concat(names)
+          end
+          opts.on("-f", "--format FORMAT", %w[css json], "css (default) or json") { |format| options[:format] = format }
+          opts.on("-o", "--output FILE", "Write to FILE, only when its content changes") { |file| options[:output] = file }
+          opts.on("--responsive BREAKPOINTS", Array, "Add breakpoint variants, e.g. sm,md,lg") do |breakpoints|
+            options[:responsive].concat(breakpoints)
+          end
+          opts.on("--prefix PREFIX", "The DaisyUI.configuration.prefix your app sets") { |prefix| options[:prefix] = prefix }
+          opts.on("-h", "--help", "Show this help") { options[:help] = true }
+        end
+      end
+
+      def help(parser)
+        @out.puts parser
+        0
+      end
+
+      def usage(parser)
+        @err.puts parser
+        1
+      end
+
+      # Only on change: a CSS watcher that sees its own input rewritten on
+      # every build rebuilds forever.
+      def write(path, content)
+        if File.exist?(path) && File.read(path) == content
+          @err.puts "daisyui-tailwind: #{path} is up to date"
+        else
+          require "fileutils"
+
+          FileUtils.mkdir_p(File.dirname(path))
+          File.write(path, content)
+          @err.puts "daisyui-tailwind: wrote #{path}"
+        end
+      end
+    end
+  end
+end

data/lib/daisy_ui/tailwind/lexer.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module DaisyUI
+  module Tailwind
+    # Reads a component's Ruby the way the manifest needs it: the words of its
+    # string literals (where its sub-part classes live, e.g. "card-body") and
+    # the constants its code references (the components it renders). Ripper
+    # keeps comments out of both.
+    #
+    # @api private
+    module Lexer
+      class << self
+        def strings(source)
+          tokens(source, :on_tstring_content).flat_map(&:split)
+        end
+
+        def constants(source)
+          tokens(source, :on_const).uniq
+        end
+
+        private
+
+        def tokens(source, type)
+          require "ripper"
+
+          ::Ripper.lex(source).filter_map { |(_position, kind, token)| token if kind == type }
+        end
+      end
+    end
+  end
+end

data/lib/daisy_ui/tailwind/manifest.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module DaisyUI
+  module Tailwind
+    # The committed tailwind_manifest.json: per component (by short name, "Button"),
+    # its class, daisyUI name, files, the components it renders and its
+    # classes; `shared` is base.rb, which every component draws on. The JSON
+    # is the contract for build scripts in other languages, so its keys are
+    # documented in the README.
+    class Manifest
+      def self.load(path = MANIFEST_PATH, root: ROOT)
+        require "json"
+
+        new(JSON.parse(File.read(path)), root:)
+      end
+
+      attr_reader :components, :shared, :root
+
+      def initialize(data, root: ROOT)
+        @components = data.fetch("components")
+        @shared = data.fetch("shared")
+        @root = root
+      end
+
+      def component_names = components.keys
+
+      # `names` ("Button" or "DaisyUI::Button") plus every component they
+      # render, transitively. Sorted.
+      def resolve(names)
+        resolved = []
+        pending = names.map { |name| canonical(name) }
+        until pending.empty?
+          name = pending.pop
+          next if resolved.include?(name)
+
+          resolved << name
+          pending.concat(components.fetch(name)["depends_on"])
+        end
+        resolved.sort
+      end
+
+      # Absolute paths of the components' files, for a literal `@source`.
+      def files(names) = names.flat_map { |name| absolute(components.fetch(name)["files"]) }
+
+      def shared_files = absolute(shared["files"])
+
+      private
+
+      def canonical(name)
+        short = name.to_s.delete_prefix("DaisyUI::")
+        return short if components.key?(short)
+
+        raise UnknownComponentError.new(name, component_names)
+      end
+
+      def absolute(paths) = paths.map { |path| File.join(root, path) }
+    end
+  end
+end

data/lib/daisy_ui/tailwind/manifest_builder.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module DaisyUI
+  module Tailwind
+    # Builds data/daisyui/tailwind_manifest.json from the components
+    # themselves (`bundle exec rake tailwind:manifest`); the manifest spec
+    # fails while the committed file differs. Per component:
+    #
+    # - `classes`: its component class (a Symbol Tailwind cannot see), its
+    #   registered modifiers and the class words in its Ruby's strings
+    # - `modifiers`: the registered modifier classes, which `responsive:`
+    #   can prefix with a breakpoint
+    # - `depends_on`: the other components its code references
+    #
+    # @api private
+    module ManifestBuilder
+      SCHEMA = 1
+      SHARED_FILE = "lib/daisy_ui/base.rb"
+
+      class << self
+        def build(root: ROOT)
+          components = gem_components(File.join(root, "lib", "daisy_ui"))
+          names = components.map(&:first)
+          {
+            "schema" => SCHEMA,
+            "shared" => shared(root),
+            "components" => components.to_h { |name, klass, file| [name, entry(klass, file:, names:, root:)] }
+          }
+        end
+
+        def generate(root: ROOT)
+          require "json"
+
+          "#{JSON.pretty_generate(build(root:))}\n"
+        end
+
+        def write(path = MANIFEST_PATH, root: ROOT)
+          json = generate(root:)
+          File.write(path, json) unless File.exist?(path) && File.read(path) == json
+          path
+        end
+
+        def entry(klass, file:, names:, root:)
+          source = File.read(file)
+          name = klass.component_class&.to_s
+          modifiers = modifier_classes(klass)
+          {
+            "class" => klass.name,
+            "name" => name,
+            "files" => [file.delete_prefix("#{root}/")],
+            "depends_on" => ((Lexer.constants(source) & names) - [short_name(klass)]).sort,
+            "modifiers" => modifiers,
+            "classes" => ([name, *modifiers].compact | Candidate.tokens(Lexer.strings(source).join(" "))).sort
+          }
+        end
+
+        private
+
+        # The gem's own components, by short name: a DaisyUI:: class defined
+        # in a file under lib/daisy_ui (not one a spec or an app defined).
+        def gem_components(lib)
+          ClassMerge::DaisyGroups.gem_components.filter_map do |klass|
+            file = Object.const_source_location(klass.name)&.first
+            [short_name(klass), klass, file] if file&.start_with?("#{lib}/")
+          end.sort_by(&:first)
+        end
+
+        def shared(root)
+          source = File.read(File.join(root, SHARED_FILE))
+          { "files" => [SHARED_FILE], "classes" => Candidate.tokens(Lexer.strings(source).join(" ")).uniq.sort }
+        end
+
+        def modifier_classes(klass)
+          classes = (klass.modifiers || {}).values.flat_map { |value| value.to_s.split }.uniq.sort
+          invalid = classes.reject { |token| Candidate.valid?(token) }
+          return classes if invalid.empty?
+
+          raise ArgumentError, "#{klass.name} registers #{invalid.map(&:inspect).join(', ')}, " \
+                               "which Tailwind cannot read from @source inline(…)"
+        end
+
+        def short_name(klass) = klass.name.split("::").last
+      end
+    end
+  end
+end

data/lib/daisy_ui/tailwind/sources.rb

@@ -0,0 +1,103 @@
+# 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
+
+      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!
+        @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
+    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,47 @@
+# 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.
+      def sources(scan: [], components: [], format: :css, responsive: [], prefix: DaisyUI.configuration.prefix)
+        manifest = self.manifest
+        used = used_components(scan:, components:, manifest:)
+        Sources.new(manifest, used, responsive:, prefix:).render(format)
+      end
+    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-17 07:27:19 UTC"
 end

data/lib/daisy_ui/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module DaisyUI
-  VERSION = "2.1.0"
+  VERSION = "2.1.1"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: daisyui
 version: !ruby/object:Gem::Version
-  version: 2.1.0
+  version: 2.1.1
 platform: ruby
 authors:
 - Mikael Henriksson
@@ -55,6 +55,7 @@ description: DaisyUI is a comprehensive Ruby UI component library that brings Da
 email: mikael@zoolutions.llc
 executables:
 - daisyui-mcp
+- daisyui-tailwind
 extensions: []
 extra_rdoc_files: []
 files:
@@ -69,7 +70,9 @@ files:
 - app/javascript/daisy_ui/controllers/daisy_tooltip_controller.min.js
 - app/javascript/daisy_ui/controllers/daisy_tooltip_controller.min.js.map
 - config/importmap.rb
+- data/daisyui/tailwind_manifest.json
 - exe/daisyui-mcp
+- exe/daisyui-tailwind
 - lib/daisy_ui.rb
 - lib/daisy_ui/accordion.rb
 - lib/daisy_ui/alert.rb
@@ -157,6 +160,15 @@ files:
 - lib/daisy_ui/table.rb
 - lib/daisy_ui/table_row.rb
 - lib/daisy_ui/tabs.rb
+- lib/daisy_ui/tailwind.rb
+- lib/daisy_ui/tailwind/candidate.rb
+- lib/daisy_ui/tailwind/command.rb
+- lib/daisy_ui/tailwind/lexer.rb
+- lib/daisy_ui/tailwind/manifest.rb
+- lib/daisy_ui/tailwind/manifest_builder.rb
+- lib/daisy_ui/tailwind/sources.rb
+- lib/daisy_ui/tailwind/unknown_component_error.rb
+- lib/daisy_ui/tailwind/usage.rb
 - lib/daisy_ui/text_rotate.rb
 - lib/daisy_ui/textarea.rb
 - lib/daisy_ui/theme_controller.rb