Added TagSet#onNewTag(Consumer<Tag> customizer)

Fixes #2330

Author: jhy

CHANGES.md

@@ -7,6 +7,7 @@
 * Removed previously deprecated methods. [#2317](https://github.com/jhy/jsoup/pull/2317)
 
 ### Improvements
+* Added `TagSet#onNewTag(Consumer<Tag> customizer)`: register a callback that’s invoked for each new or cloned Tag when it’s inserted into the set. Enables dynamic tweaks of tag options (for example, marking all custom tags as self-closing, or everything in a given namespace as preserving whitespace).
 * Made `TokenQueue` and `CharacterReader` autocloseable, to ensure that they will release their buffers back to the buffer pool, for later reuse.
 * Added `Selector#evaluatorOf(String css)`, as a clearer way to obtain an Evaluator from a CSS query. An alias of `QueryParser.parse(String css)`.
 * Custom tags (defined via the `TagSet`) in a foreign namespace (e.g. SVG) can be configured to parse as data tags.

src/main/java/org/jsoup/parser/TagSet.java

@@ -4,6 +4,7 @@
 import org.jsoup.internal.SharedConstants;
 import org.jspecify.annotations.Nullable;
 
+import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.Map;
 import java.util.Objects;
@@ -23,8 +24,9 @@
 public class TagSet {
     static final TagSet HtmlTagSet = initHtmlDefault();
 
-    final Map<String, Map<String, Tag>> tags = new HashMap<>(); // namespace -> tag name -> Tag
-    final @Nullable TagSet source; // source to pull tags from on demand
+    private final Map<String, Map<String, Tag>> tags = new HashMap<>(); // namespace -> tag name -> Tag
+    private final @Nullable TagSet source; // source to pull tags from on demand
+    private @Nullable ArrayList<Consumer<Tag>> customizers; // optional onNewTag tag customizer
 
     /**
      Returns a mutable copy of the default HTML tag set.
@@ -57,6 +59,12 @@ public TagSet add(Tag tag) {
 
     /** Adds the tag, but does not set defined. Used in .valueOf */
     private void doAdd(Tag tag) {
+        if (customizers != null) {
+            for (Consumer<Tag> customizer : customizers) {
+                customizer.accept(tag);
+            }
+        }
+
         tags.computeIfAbsent(tag.namespace, ns -> new HashMap<>())
             .put(tag.tagName, tag);
     }
@@ -149,6 +157,34 @@ public Tag valueOf(String tagName, String namespace) {
         return valueOf(tagName, namespace, ParseSettings.preserveCase);
     }
 
+    /**
+     Register a callback to customize each {@link Tag} as it's added to this TagSet.
+     <p>Customizers are invoked once per Tag, when they are added (explicitly or via the valueOf methods).</p>
+
+     <p>For example, to allow all unknown tags to be self-closing during when parsing as HTML:</p>
+     <pre><code>
+     Parser parser = Parser.htmlParser();
+     parser.tagSet().onNewTag(tag -> {
+     if (!tag.isKnownTag())
+        tag.set(Tag.SelfClose);
+     });
+
+     Document doc = Jsoup.parse(html, parser);
+     </code></pre>
+
+     @param customizer a {@code Consumer<Tag>} that will be called for each newly added or cloned Tag; callers can
+     inspect and modify the Tag's state (e.g. set options)
+     @return this TagSet, to allow method chaining
+     @since 1.21.0
+     */
+    public TagSet onNewTag(Consumer<Tag> customizer) {
+        Validate.notNull(customizer);
+        if (customizers == null)
+            customizers = new ArrayList<>();
+        customizers.add(customizer);
+        return this;
+    }
+
     @Override
     public boolean equals(Object o) {
         if (!(o instanceof TagSet)) return false;

src/test/java/org/jsoup/parser/TagSetTest.java

@@ -4,6 +4,8 @@
 import org.jsoup.nodes.Element;
 import org.junit.jupiter.api.Test;
 
+import java.util.concurrent.atomic.AtomicInteger;
+
 import static org.jsoup.parser.Parser.NamespaceHtml;
 import static org.junit.jupiter.api.Assertions.*;
 
@@ -105,4 +107,81 @@ public class TagSetTest {
         c1.clear(Tag.Known);
         assertFalse(c1.isKnownTag());
     }
+
+    @Test void canCustomizeAll() {
+        TagSet tags = TagSet.Html();
+        tags.onNewTag(tag -> tag.set(Tag.SelfClose));
+        assertTrue(tags.get("script", NamespaceHtml).is(Tag.SelfClose));
+        assertTrue(tags.valueOf("SCRIPT", NamespaceHtml).is(Tag.SelfClose));
+        assertTrue(tags.valueOf("custom", NamespaceHtml).is(Tag.SelfClose));
+
+        Tag foo = new Tag("foo", NamespaceHtml);
+        assertFalse(foo.is(Tag.SelfClose));
+        tags.add(foo);
+        assertTrue(foo.is(Tag.SelfClose));
+    }
+
+    @Test void canCustomizeSome() {
+        TagSet tags = TagSet.Html();
+        tags.onNewTag(tag -> {
+            if (!tag.isKnownTag()) {
+                tag.set(Tag.SelfClose);
+            }
+        });
+        assertFalse(tags.valueOf("script", NamespaceHtml).is(Tag.SelfClose));
+        assertFalse(tags.valueOf("SCRIPT", NamespaceHtml).is(Tag.SelfClose));
+        assertTrue(tags.valueOf("custom-tag", NamespaceHtml).is(Tag.SelfClose));
+    }
+
+    @Test void canParseWithCustomization() {
+        // really would use tag.valueOf("script"); just a test example here
+        Parser parser = Parser.htmlParser();
+        parser.tagSet().onNewTag(tag -> {
+            if (tag.normalName().equals("script"))
+                tag.set(Tag.SelfClose);
+        });
+
+        Document doc = Jsoup.parse("<script />Text", parser);
+        assertEquals("<html>\n <head>\n  <script></script>\n </head>\n <body>Text</body>\n</html>", doc.html());
+        // self closing bit still produces valid HTML
+    }
+
+    @Test void canParseWithGeneralCustomization() {
+        Parser parser = Parser.htmlParser();
+        parser.tagSet().onNewTag(tag -> {
+            if (!tag.isKnownTag())
+                tag.set(Tag.SelfClose);
+        });
+
+        Document doc = Jsoup.parse("<custom-data />Bar <script />Text", parser);
+        assertEquals("<custom-data></custom-data>Bar\n<script>Text</script>", doc.body().html());
+    }
+
+    @Test void supportsMultipleCustomizers() {
+        TagSet tags = TagSet.Html();
+        tags.onNewTag(tag -> {
+            if (tag.normalName().equals("script"))
+                tag.set(Tag.SelfClose);
+        });
+        tags.onNewTag(tag -> {
+            if (!tag.isKnownTag())
+                tag.set(Tag.RcData);
+        });
+
+        assertTrue(tags.valueOf("script", NamespaceHtml).is(Tag.SelfClose));
+        assertFalse(tags.valueOf("script", NamespaceHtml).is(Tag.RcData));
+        assertTrue(tags.valueOf("custom-tag", NamespaceHtml).is(Tag.RcData));
+    }
+
+    @Test void customizersArePreservedInSource() {
+        TagSet source = TagSet.Html();
+        source.onNewTag(tag -> tag.set(Tag.RcData));
+        TagSet copy = new TagSet(source);
+        assertTrue(copy.valueOf("script", NamespaceHtml).is(Tag.RcData));
+        assertTrue(source.valueOf("script", NamespaceHtml).is(Tag.RcData));
+
+        copy.onNewTag(tag -> tag.set(Tag.Void));
+        assertTrue(copy.valueOf("custom-tag", NamespaceHtml).is(Tag.Void));
+        assertFalse(source.valueOf("custom-tag", NamespaceHtml).is(Tag.Void));
+    }
 }