glyphs 0.4.0 → 0.4.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 83fd5e39450d1ac698d0add8d4344ecbd9001783695ac15f48f7276aba89a05f
-  data.tar.gz: a1c570feaf9d4e623958a626d1a5ffe42fc55d0e4347cd659539e00335a8af3d
+  metadata.gz: 798fe439ca9ea93ff3bfb84f23de90f87abd6ffee953cd85de5543066b52a4f0
+  data.tar.gz: 58829c2ec4bf5ed6aaa24da8b40a376b7aae48525277be499eae957754a99c11
 SHA512:
-  metadata.gz: b077d3f979ffcd2a41244c48fa6bba440400f44fb48d6033d35208661bfbfc434b65b22a44ee4548771bcac6ac87a97622e14dd6bb4303768066ae61a272ddb4
-  data.tar.gz: a0b9a383c8197cc0079ecea51e3c9879fcb884b12e852aecf6f8a21dd8b0a06e9624bfb753f6a2faf02eec9043c90f4570e2ff40717ed2a648c9b93b52888b62
+  metadata.gz: 49acc1efae75b8d2eb0fac2079ef20c2d5fb211a519c598d61f306453c3dbc000f4ee2fd4bb75090b10a63f009e8bbbddde0e4a3277bc340b58e5eead644eec2
+  data.tar.gz: 7b3adbeb6816fbeb13eea1584a33ef1cbcb241339c7caedab14b92b44a185050ebd8240ae0ed99ab5715cc8ccaeb471968f491354e009112eee76ccbd23831a3

data/CHANGELOG.md

@@ -4,6 +4,15 @@
 
 ### Added
 
+- **`config.merge_default_data` keeps a library's default data next to a
+  call's own.** Off by default. The icons gem replaces a library's configured
+  `default.data` with a call's `data:` hash, so a default marker such as
+  `data-icon` disappears from exactly the icons that carry data of their own.
+  With the setting on, the call's `data:` hash is merged over the defaults (the
+  call's keys win, its hash is not mutated; `data: nil` keeps the defaults, uncached).
+  Cached and uncached renders are byte-identical, the cache key is unchanged,
+  and a library with no default data renders as before. With it off, output is
+  unchanged. Refs #40
 - **A non-main Ractor renders icons it has not cached.** A miss there used to
   raise `Ractor::IsolationError` (`@configuration from Icons`), because the
   icons gem reads an unshareable module ivar and parses with Nokogiri, which
@@ -15,6 +24,23 @@
   `Glyphs::MainRactor::Unavailable` naming the icon, and `Glyphs.preload_svg`
   still seeds a Ractor's cache. glyphs does not depend on ractor-dispatch: add
   it outside Rails 8.2. Refs zoolutions/phlex-reactive#363
+- **`config.raise_on_prunable` fails a render the prune would delete.** Off by
+  default. With it on, typically in the test environment, rendering such an icon
+  raises `Glyphs::PrunableIconError`, naming the library, variant and name, so a
+  test fails instead of production. The guard asks the pruner, so under one
+  configuration the two agree. The first uncached render scans the source, once
+  per process; with the setting off nothing is scanned. Enabling it may fail specs, and each such
+  failure is an icon that would have gone missing in production. Refs #35
+
+### Fixed
+
+- **`glyphs:prune_icons` no longer deletes icons forwarded through a wrapper
+  component.** A file that passes a non-literal under a key like an icon
+  (`Badge(icon:)`, `Badge(icon: row.first)`) now keeps its icon-name-shaped
+  literals for every dynamically-rendered library. They were dropped when the
+  file itself had no dynamic icon call, so the icon raised
+  `Icons::IconNotFound` in production only. Pruning can only keep a little more
+  than before. Refs #35
 
 ## [0.3.0] - 2026-10-15
 

data/README.md

@@ -105,6 +105,16 @@ Glyphs.configure do |config|
   # on every render that goes uncached.
   config.cache_svgs = true
 
+  # Merge a call's data: hash over the library's configured default data
+  # (`default.data` in the icons configuration) instead of replacing it, as the
+  # icons gem does. The call's keys win on a conflict; its hash is not mutated.
+  # data: nil keeps the defaults, as no data: does; any other non-hash data:
+  # renders as the icons gem renders it. Both render uncached. Cached and
+  # uncached renders are identical either way. Default: false (the icons gem's behavior).
+  # The cache holds the merged markup: call Glyphs.reset_cache! after changing
+  # this or the icons gem's default data at runtime (tests).
+  config.merge_default_data = false
+
   # How many icons the cache holds (least recently used evicted first). One
   # cache per Ractor, so a plain threaded server has one. Default: 1024.
   config.svg_cache_size = 1024
@@ -137,6 +147,8 @@ Active Support; elsewhere, add `gem "ractor-dispatch"`. The markup is the main R
 the calling Ractor's cache keeps it, so each icon crosses once per cache entry; cache hits never leave the
 Ractor. The missing-icon policy runs on the main Ractor too, `on_missing_icon` included. A call with an
 attribute that renders uncached, or any call with `cache_svgs = false`, goes to the main Ractor every time.
+`merge_default_data` reads the default data where the icons gem renders, on the main Ractor, so it adds no
+crossing: a hit merges the call's `data:` in the calling Ractor. With it on, a non-hash `data:` (`nil` included) renders uncached.
 
 Without ractor-dispatch, a miss in a non-main Ractor raises `Glyphs::MainRactor::Unavailable`, naming the
 icon. You can still render on the main Ractor and hand the markup over with `Glyphs.preload_svg`; cache hits
@@ -180,11 +192,48 @@ The scanner resolves them from source, so you rarely need `keep_icons` at all:
   constant named like one (`ICON = :bell`, `STATUS_ICONS = { .. => :warning }`,
   including trailing `.freeze`) — are kept for every dynamically-rendered
   library, so a name declared in one file and rendered from another survives.
+- **Forwarded** — a file that passes a non-literal under a key like an icon
+  (`Badge(icon:)`, `Badge(icon: row.first)`) hands a name on to a wrapper
+  component, so every icon-name-shaped literal in that file is kept for every
+  dynamically-rendered library. `ROWS = [[:bell, 1]]` survives when the row
+  reaches `Badge(icon:)`, and `Badge`'s `LucideIcon(@icon)` lives in another file.
 
 Only literals are harvested, so the scanner never invents a reference; the
 worst case is keeping a coincidentally icon-named string, which the post-prune
 verification tolerates.
 
+A static scan can't follow every value. A literal passed positionally to a
+wrapper (`m.row("Alerts", :anchor)`) is still pruned, and so is a forwarded
+keyword in a template, which is text-scanned. Nothing fails until production:
+development and test keep every SVG, and the post-prune verification doesn't
+assert harvested names. `raise_on_prunable` closes that gap.
+
+### `raise_on_prunable` — fail the test that renders a prunable icon
+
+```ruby
+# config/environments/test.rb, or an initializer guarded by Rails.env.test?
+Glyphs.configure do |config|
+  config.raise_on_prunable = true
+end
+```
+
+With it on, rendering an icon the prune would delete raises
+`Glyphs::PrunableIconError`, naming the library, variant and name. Every page a
+test renders becomes a check, and each failure is a production bug: name the icon
+in an icon position (`icon: :anchor`, an `ICON` constant) or list it in
+`keep_icons`.
+
+The guard asks the pruner itself, so the two agree, including on `keep_icons`
+globs and on the libraries a prune leaves alone. That holds for the configuration
+the test runs with: a `keep_icons`, `fallback_icons` or `prune_source_globs` that
+differs by `Rails.env` makes the guard answer for a different keep-set than your
+image build prunes with. The first uncached render scans
+your source, once per process (a parallel test worker scans for itself), and
+cache hits never reach the check. A name that doesn't exist at all still meets
+the missing-icon policy. The default is `false`, which scans nothing, and
+source changed after the scan isn't seen until the process restarts, so keep this
+in the test environment.
+
 ### `keep_icons` — the last-resort escape hatch
 
 For names a static scan genuinely can't see — read from a database, an ENV var,

data/lib/glyphs/configuration.rb

@@ -18,14 +18,20 @@ module Glyphs
     # cache_svgs: memoize rendered SVGs per [library, variant, name]; the
     #   caller's attributes are applied to the cached markup on every call.
     # svg_cache_size: how many icons each Ractor's LRU cache holds (1024).
+    # merge_default_data: boolean; when true, a caller's data: hash is merged
+    #   over the library/variant's configured default data (the caller's keys
+    #   win) instead of replacing it, as the icons gem does. Default: false.
     # keep_icons: icons the pruner must keep despite no static reference
     #   (dynamic / data-driven names). A flat list of names/globs, or a
     #   { library => [names/globs] } hash. fallback_icons are always kept.
     # prune_source_globs: extra locations the pruner's scanner text-scans IN
     #   ADDITION to the built-in Ruby/template defaults — e.g. a config file that
     #   names icons. Never replaces the defaults (nil = defaults only).
+    # raise_on_prunable: boolean; when true, rendering an icon glyphs:prune_icons
+    #   would delete raises Glyphs::PrunableIconError. For the test environment:
+    #   the first uncached render scans the source, once per process.
     attr_accessor :raise_on_missing, :on_missing_icon, :fallback_icons, :cache_svgs,
-      :keep_icons, :prune_source_globs
+      :keep_icons, :prune_source_globs, :raise_on_prunable, :merge_default_data
     attr_reader :svg_cache_size
 
     def initialize
@@ -36,6 +42,8 @@ module Glyphs
       @svg_cache_size = DEFAULT_SVG_CACHE_SIZE
       @keep_icons = []
       @prune_source_globs = nil
+      @raise_on_prunable = false
+      @merge_default_data = false
     end
 
     def svg_cache_size=(size)

data/lib/glyphs/default_data.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Glyphs
+  # config.merge_default_data: merges a library's configured default data under
+  # a caller's data: hash, which the icons gem would otherwise replace it with.
+  # Reads the icons gem's configuration, so it runs on the main Ractor only
+  # (Glyphs.build_svg, which a non-main Ractor reaches through MainRactor).
+  # A default data key named like SvgTemplate's slot marker (glyphs-data-slot)
+  # would be dropped by the cached data: template, so such defaults are not
+  # merged: both paths render as the icons gem does.
+  module DefaultData
+    SLOT_NAME = SvgTemplate::SLOT_ATTRIBUTE.delete_prefix("data-").freeze
+
+    class << self
+      # The attributes with the default data merged under a data: hash, or
+      # without a data: nil (the defaults alone, as with no data:), when the
+      # library has default data; else the attributes as given. A new Hash: the
+      # caller's is never mutated.
+      def merge(attributes, library:, variant:)
+        return attributes unless attributes.key?(:data)
+
+        data = attributes[:data]
+        return attributes unless data.nil? || data.is_a?(Hash)
+
+        defaults = lookup(library:, variant:)
+        return attributes unless mergeable?(defaults)
+
+        data.nil? ? attributes.except(:data) : attributes.merge(data: by_name(defaults, data))
+      end
+
+      private
+
+      def mergeable?(defaults)
+        defaults.is_a?(Hash) && !defaults.empty? && defaults.each_key.none? { |key| key.to_s.tr("_", "-") == SLOT_NAME }
+      end
+
+      # One entry per attribute name, however its key is spelled (:toggle_target,
+      # "toggle-target"): at the position its name first appears, with the value
+      # it was given last, the caller's after the defaults. That is how a cache
+      # hit splices the caller's data over the template's defaults.
+      def by_name(defaults, data)
+        merged = {}
+        defaults.each { |key, value| merged[key.to_s.tr("_", "-")] = value }
+        data.each { |key, value| merged[key.to_s.tr("_", "-")] = value }
+        merged
+      end
+
+      # The icons gem's own lookup (Icons::Icon::Configurable): the variant, else
+      # the library's default_variant, else the global default_variant.
+      def lookup(library:, variant:)
+        icons = Icons.configuration
+        library = library.to_sym
+        variant ||= icons.libraries.dig(library, :default_variant) || icons.default_variant
+        variant = variant.to_s.empty? ? nil : variant.to_sym
+        (icons.libraries.dig(*[library, variant].compact) || {}).dig(:default, :data)
+      end
+    end
+  end
+end

data/lib/glyphs/icon_pruner.rb

@@ -38,14 +38,23 @@ module Glyphs
           next
         end
 
-        keep = keep_names_for(library, variant)
-        stat = prune_group(library, variant, files, keep, deleted_names)
-        stats << stat
+        stats << prune_group(library, variant, files, unkept_files(library, variant, files), deleted_names)
       end
 
       PruneReport.new(stats:, deleted_names:, dry_run: @dry_run)
     end
 
+    # The Set of IconReferences #call would delete: same files, same keep-sets.
+    # Deletes nothing and warns about nothing.
+    def prunable
+      groups = grouped_files.select { |(library, _), _| library_used?(library) }
+      groups.each_with_object(Set.new) do |((library, variant), files), references|
+        unkept_files(library, variant, files).each do |path|
+          references << IconReference.new(library:, variant:, name: File.basename(path, ".svg"))
+        end
+      end
+    end
+
     private
 
     # { [library, variant] => [absolute svg paths] }, excluding the animated lib.
@@ -69,25 +78,19 @@ module Glyphs
       end
     end
 
-    def prune_group(library, variant, files, keep, deleted_names)
-      kept = 0
-      deleted = 0
-      bytes_freed = 0
-
-      files.each do |path|
-        name = File.basename(path, ".svg")
-        if keep_file?(name, keep)
-          kept += 1
-          next
-        end
+    # The one decision of what goes, shared by #call and #prunable.
+    def unkept_files(library, variant, files)
+      keep = keep_names_for(library, variant)
+      files.reject { |path| keep_file?(File.basename(path, ".svg"), keep) }
+    end
 
-        deleted += 1
-        bytes_freed += File.size(path)
-        deleted_names << name
-        File.delete(path) unless @dry_run
-      end
+    def prune_group(library, variant, files, unkept, deleted_names)
+      bytes_freed = unkept.sum { |path| File.size(path) }
+      deleted_names.concat(unkept.map { |path| File.basename(path, ".svg") })
+      unkept.each { |path| File.delete(path) } unless @dry_run
 
-      PruneReport::LibraryStat.new(library:, variant:, kept:, deleted:, bytes_freed:)
+      PruneReport::LibraryStat.new(library:, variant:, kept: files.size - unkept.size, deleted: unkept.size,
+        bytes_freed:)
     end
 
     def keep_file?(name, keep)

data/lib/glyphs/prunable_icon_error.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Glyphs
+  # Raised on render, with Configuration#raise_on_prunable on, for an icon that
+  # exists now and that glyphs:prune_icons would delete from the image. Not an
+  # Icons::IconNotFound: the missing-icon policy must not turn it into a fallback.
+  class PrunableIconError < StandardError; end
+end

data/lib/glyphs/prune_guard.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Glyphs
+  # Backs Configuration#raise_on_prunable: a render of an icon the prune would
+  # delete fails in the test suite instead of in production, where development's
+  # full SVG tree no longer hides it. Dynamic keeps are advisory, so
+  # PruneRunner#verify! cannot catch this; a render names a real icon, so here
+  # it is safe to fail.
+  #
+  # It asks the pruner, so under one configuration the two agree, and it asks
+  # once: the scan runs in the constructor and #check! only reads the result. It
+  # deletes nothing. Glyphs keeps one per process, replacing it when #current?
+  # says the settings behind that answer changed.
+  class PruneGuard
+    def initialize(config: Glyphs.configuration, runner: PruneRunner.new(config:))
+      @keep_settings = keep_settings(config)
+      @prunable = runner.prunable
+    end
+
+    def current?(config)
+      @keep_settings == keep_settings(config)
+    end
+
+    def check!(name:, library:, variant:)
+      library = library.to_sym
+      variant = variant.nil? ? IconReference.default_variant_for(library) : IconReference.normalize_variant(variant)
+      reference = IconReference.new(library:, variant:, name: name.to_s)
+      raise PrunableIconError, message(reference) if @prunable.include?(reference)
+    end
+
+    private
+
+    # A hash of the values, so a list changed in place reads as a change.
+    def keep_settings(config)
+      [config.keep_icons, config.fallback_icons, config.prune_source_globs].hash
+    end
+
+    def message(reference)
+      icon = [reference.library, reference.variant, reference.name].compact.join("/")
+      "glyphs:prune_icons would delete #{icon}, so this render would fail in production. " \
+        "Name it in an icon position (`icon: :#{reference.name.tr('-', '_')}`, an `ICON` constant) " \
+        "or list it in keep_icons."
+    end
+  end
+end

data/lib/glyphs/prune_runner.rb

@@ -28,6 +28,12 @@ module Glyphs
       report
     end
 
+    # The IconReferences a prune would delete, deleting nothing: the pruner's own
+    # answer over the same scan and keep-sets #call uses.
+    def prunable
+      pruner.prunable
+    end
+
     # Asserts every kept icon resolves to a file on disk. Raises
     # VerificationError listing the first few misses.
     def verify!

data/lib/glyphs/source_scanner.rb

@@ -156,7 +156,7 @@ module Glyphs
     # name the AST can't read (`LucideIcon(tile[:icon])`) — across every scanned
     # Ruby file, then turns that evidence into IconReferences.
     #
-    # Two sources of candidate names, both harvested only from literals so we
+    # Three sources of candidate names, all harvested only from literals so we
     # never invent a reference:
     #
     #   1. file-scoped — a file that dynamically renders library L contributes
@@ -166,6 +166,10 @@ module Glyphs
     #      (a hash pair keyed `/icon/i`, or a constant named `/ICON/`) are
     #      candidates for EVERY dynamically-rendered library, since a bare
     #      `ICON = :bell` in one file is often rendered from another.
+    #   3. forwarded — a file passing a non-literal under a key like an icon
+    #      (`Badge(icon:)`, `Badge(icon: row.first)`) hands a name on to a wrapper
+    #      that renders it elsewhere, so ALL its literals are candidates for
+    #      every dynamically-rendered library, as declarations are.
     #
     # Names resolve at the library's default variant: a dynamic call names no
     # variant in practice, and the pruner keeps per (library, variant).
@@ -179,6 +183,7 @@ module Glyphs
       # Folds one file's visitor results into the running accumulator.
       def absorb(visitor)
         @declaration_literals.merge(visitor.declaration_literals)
+        @declaration_literals.merge(visitor.file_literals) if visitor.forwards_icon
         return if visitor.dynamic_libraries.empty?
 
         @dynamic_libraries.merge(visitor.dynamic_libraries)
@@ -205,18 +210,28 @@ module Glyphs
       # Excludes CSS classes (spaces/slashes), paths, and interpolated strings.
       ICON_NAME_LITERAL = /\A[a-z][a-z0-9_-]*\z/
 
+      # Values of an icon-keyed pair that forward nothing: a declaration harvest
+      # reads the names, and `icon: nil` or `icon_size: 16` names no icon at all.
+      LITERAL_VALUES = [
+        Prism::SymbolNode, Prism::StringNode, Prism::NilNode, Prism::TrueNode, Prism::FalseNode,
+        Prism::IntegerNode, Prism::FloatNode
+      ].freeze
+
       # Libraries this file renders with a dynamic (non-literal) first argument.
       attr_reader :dynamic_libraries
       # Icon-name-shaped literals anywhere in this file (file-scoped candidates).
       attr_reader :file_literals
       # Literals in icon-declaration positions (`icon:` pairs, `ICON` constants).
       attr_reader :declaration_literals
+      # Whether this file passes a non-literal under a key like an icon.
+      attr_reader :forwards_icon
 
       def initialize(references)
         @references = references
         @dynamic_libraries = Set.new
         @file_literals = Set.new
         @declaration_literals = Set.new
+        @forwards_icon = false
         super()
       end
 
@@ -247,10 +262,14 @@ module Glyphs
       end
 
       # `icon: :activity` / `menu_icon: "gear"` — a hash pair keyed like an icon
-      # declares an icon name, wherever it lives.
+      # declares an icon name, wherever it lives. A non-literal value there
+      # (`icon:`, `icon: row.first`) forwards a name instead.
       def visit_assoc_node(node)
         key = node.key
-        collect_declaration(node.value) if key.is_a?(Prism::SymbolNode) && key.unescaped.match?(/icon/i)
+        if key.is_a?(Prism::SymbolNode) && key.unescaped.match?(/icon/i)
+          collect_declaration(node.value)
+          @forwards_icon ||= forwarded_value?(node.value)
+        end
         super
       end
 
@@ -258,6 +277,20 @@ module Glyphs
 
       attr_reader :references
 
+      # A container forwards when anything inside it does: `icon: [:a, pick]`.
+      def forwarded_value?(value_node)
+        value_node = unwrap_declaration_wrappers(value_node)
+        case value_node
+        when Prism::ArrayNode then value_node.elements.any? { |element| forwarded_value?(element) }
+        when Prism::HashNode then value_node.elements.any? { |element| forwarded_pair?(element) }
+        else LITERAL_VALUES.none? { |literal| value_node.is_a?(literal) }
+        end
+      end
+
+      def forwarded_pair?(element)
+        !element.is_a?(Prism::AssocNode) || forwarded_value?(element.value)
+      end
+
       def record(node)
         method = node.name.to_s
         if GENERIC_CALLS.include?(node.name)

data/lib/glyphs/svg_template.rb

@@ -18,6 +18,9 @@ module Glyphs
   # A caller's data: replaces the library's default data (the icons gem merges
   # them that way) and lands where the defaults would have, so data: calls use
   # a template rendered with DATA_SLOT, whose marker attribute holds that place.
+  # With merge_default_data on, that template is rendered with the default data
+  # before the marker (Glyphs::DefaultData), and a caller's key that names a
+  # default replaces it in place, as rendering the merged hash would.
   class SvgTemplate
     DATA_SLOT = { data: { "glyphs-data-slot" => "" }.freeze }.freeze
     SLOT_ATTRIBUTE = "data-glyphs-data-slot"

data/lib/glyphs/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Glyphs
-  VERSION = "0.4.0"
+  VERSION = "0.4.2"
 end

data/lib/glyphs.rb

@@ -38,6 +38,8 @@ module Glyphs
   # readers never take it, so svg_for runs in any Ractor once finalized.
   @lock = Monitor.new
   @configuration = Configuration.new
+  @prune_guard = nil
+  @prune_guard_lock = Mutex.new
 
   class << self
     # The current configuration: a plain read, shareable after finalize!.
@@ -49,6 +51,7 @@ module Glyphs
     end
 
     def reset_configuration!
+      @prune_guard_lock.synchronize { @prune_guard = nil }
       @lock.synchronize { @configuration = Configuration.new }
     end
 
@@ -89,8 +92,15 @@ module Glyphs
     # policy (raise / instrument / fallback) and the per-Ractor cache: one
     # entry per [library, variant, name], the caller's attributes applied to
     # the cached markup on every call.
+    #
+    # With merge_default_data on, the library's default data is merged under a
+    # caller's data: hash when the icons gem renders (build_svg, main Ractor
+    # only, where its configuration is readable). The data: template is then
+    # rendered with the defaults beside the slot marker, so a cache hit splices
+    # the caller's keys over them exactly as the merged hash would render. A
+    # non-hash data: renders uncached (data: nil keeps the defaults, if any).
     def svg_for(name:, library:, variant:, attributes:)
-      return render_svg(name:, library:, variant:, attributes:) unless configuration.cache_svgs
+      return render_svg(name:, library:, variant:, attributes:) if uncached?(attributes)
 
       data = attributes.key?(:data)
       template = svg_cache.compute_if_absent([library, variant, name, data], configuration.svg_cache_size) do
@@ -120,6 +130,13 @@ module Glyphs
 
     private
 
+    def uncached?(attributes)
+      config = configuration
+      return true unless config.cache_svgs
+
+      config.merge_default_data && attributes.key?(:data) && !attributes[:data].is_a?(Hash)
+    end
+
     # A non-main Ractor cannot run the icons gem, so it renders on the main
     # Ractor (see MainRactor); the missing-icon policy runs there too.
     def render_svg(name:, library:, variant:, attributes:)
@@ -128,13 +145,30 @@ module Glyphs
       resolve_svg(name:, library:, variant:, attributes:)
     end
 
+    # Only a miss gets here, and only on the main Ractor. A name with no file is
+    # never prunable, so it passes the guard and meets the missing-icon policy.
     def resolve_svg(name:, library:, variant:, attributes:)
+      prune_guard&.check!(name:, library:, variant:)
       build_svg(name:, library:, variant:, attributes:)
     rescue Icons::IconNotFound => e
       handle_missing_icon(e, name:, library:, variant:, attributes:)
     end
 
+    # nil while raise_on_prunable is off, so that path reads nothing. A racing
+    # thread waits for the first scan rather than repeating it. Not @lock: this
+    # runs under the SvgCache mutex, and a configure block holding @lock may render.
+    def prune_guard
+      config = configuration
+      return unless config.raise_on_prunable
+
+      @prune_guard_lock.synchronize do
+        @prune_guard = PruneGuard.new(config:) unless @prune_guard&.current?(config)
+        @prune_guard
+      end
+    end
+
     def build_svg(name:, library:, variant:, attributes:)
+      attributes = DefaultData.merge(attributes, library:, variant:) if configuration.merge_default_data
       Icons::Icon.new(name:, library:, variant:, arguments: attributes).svg
     end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: glyphs
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.4.2
 platform: ruby
 authors:
 - Mikael Henriksson
@@ -68,6 +68,7 @@ files:
 - lib/glyphs/animated_icon.rb
 - lib/glyphs/box_icon.rb
 - lib/glyphs/configuration.rb
+- lib/glyphs/default_data.rb
 - lib/glyphs/feather_icon.rb
 - lib/glyphs/flag_icon.rb
 - lib/glyphs/hero_icon.rb
@@ -79,6 +80,8 @@ files:
 - lib/glyphs/lucide_icon.rb
 - lib/glyphs/main_ractor.rb
 - lib/glyphs/phosphor_icon.rb
+- lib/glyphs/prunable_icon_error.rb
+- lib/glyphs/prune_guard.rb
 - lib/glyphs/prune_report.rb
 - lib/glyphs/prune_runner.rb
 - lib/glyphs/radix_icon.rb