dommy 0.7.0 → 0.8.0

data/lib/dommy/internal/css_pseudo_handlers.rb

@@ -24,5 +24,114 @@ module Dommy
     end
 
     CSS_PSEUDO_HANDLERS = CSSPseudoHandlers.new
+
+    # Adds `:scope` support. Nokogiri compiles `:scope` into a custom XPath
+    # function `nokogiri:scope(.)`, calling it as `scope(node_set)`; a scoped
+    # query (`el.querySelector(":scope > p")`) resolves it to the context
+    # element, so only that element matches. One instance per query — it carries
+    # the context node.
+    class ScopedCSSPseudoHandlers < CSSPseudoHandlers
+      def initialize(scope_node)
+        @scope_node = scope_node
+      end
+
+      def scope(list)
+        list.find_all { |node| node.pointer_id == @scope_node.pointer_id }
+      end
+    end
+
+    def self.scoped_pseudo_handlers(scope_node)
+      ScopedCSSPseudoHandlers.new(scope_node)
+    end
+
+    # The complete set of CSS pseudo-classes (+ the four legacy single-colon
+    # pseudo-elements). A `:identifier` outside this set is an unknown selector
+    # token → SyntaxError, whereas a known-but-unimplemented one (`:hover`) is a
+    # valid selector that simply matches nothing.
+    KNOWN_PSEUDOS = %w[
+      active any-link autofill blank checked current default defined disabled empty
+      enabled first first-child first-of-type focus focus-visible focus-within
+      fullscreen future has host hover in-range indeterminate invalid is lang
+      last-child last-of-type left link local-link modal not nth-child nth-col
+      nth-last-child nth-last-col nth-last-of-type nth-of-type only-child
+      only-of-type optional out-of-range past placeholder-shown playing paused
+      read-only read-write required right root scope target target-within
+      user-invalid user-valid valid visited where dir
+      before after first-line first-letter
+    ].to_set.freeze
+
+    # Validate a non-null CSS selector for `querySelector`/`matches`/`closest`,
+    # raising SyntaxError for syntactically invalid selectors. Delegates to the
+    # full grammar parser (SelectorParser), which catches everything the old
+    # heuristic did (empty string, leading combinator, unknown pseudo-class) plus
+    # the rest of the Selectors grammar (`[*=v]`, `..x`, `div % p`, unknown
+    # pseudo-elements, undeclared namespaces, …) that Nokogiri silently accepts.
+    def self.validate_selector!(selector)
+      SelectorParser.validate!(selector.to_s)
+    end
+
+    # Coerce the JS argument of a query method (querySelector/All) per WebIDL: the
+    # selector is a *non-nullable* DOMString, so JS `null` → "null" and
+    # `undefined` → "undefined" (which then match `<null>` / `<undefined>` typed
+    # elements rather than returning nothing), while a missing argument is a
+    # TypeError. Used at every JS dispatch site so the behaviour is uniform.
+    def self.css_query_arg!(args)
+      raise ::Dommy::Bridge::TypeError, "1 argument required, but only 0 present" if args.empty?
+
+      value = args[0]
+      return "null" if value.nil?
+      return "undefined" if defined?(::Dommy::Bridge::UNDEFINED) && value.equal?(::Dommy::Bridge::UNDEFINED)
+
+      value
+    end
+
+    # Nokogiri's CSS→XPath compiler chokes on an escaped colon INSIDE an
+    # attribute selector (`[xlink\:href]`, a namespaced/SVG attribute → "Invalid
+    # predicate"), though it handles escaped colons in class/id selectors fine
+    # (`.md\:flex`, `#a\:b` — Tailwind). Those attribute selectors target
+    # XML-namespaced attributes the HTML backend doesn't model, so drop just the
+    # comma-clauses that use them; the rest of the selector list is preserved.
+    # (Real frameworks hit this constantly — Turbo's click handler matches
+    # `a[href], a[xlink\:href]` on every click.) Returns a backend-safe selector;
+    # if every clause was unsupported, returns one that compiles but never
+    # matches.
+    ATTR_ESCAPED_COLON = /\[[^\]]*\\:[^\]]*\]/
+    def self.backend_safe_selector(selector)
+      # First drop clauses whose subject is a pseudo-element (`::before`,
+      # `:first-line`) — they match no element, and the backend can't compile
+      # `::`. Then drop the escaped-colon attribute clauses below.
+      s = SelectorParser.matchable_selector(selector.to_s)
+      return s unless s.include?('\\') && s.match?(ATTR_ESCAPED_COLON)
+
+      kept = split_selector_list(s).reject { |clause| clause.match?(ATTR_ESCAPED_COLON) }
+      kept.empty? ? ":not(*)" : kept.join(", ")
+    end
+
+    # Split a selector list on top-level commas only (commas inside [...], (...),
+    # or quotes are part of a single complex selector and must not split it).
+    def self.split_selector_list(selector)
+      clauses = []
+      depth = 0
+      quote = nil
+      current = +""
+      selector.each_char do |ch|
+        if quote
+          quote = nil if ch == quote
+        elsif ch == '"' || ch == "'"
+          quote = ch
+        elsif ch == "[" || ch == "("
+          depth += 1
+        elsif ch == "]" || ch == ")"
+          depth -= 1 if depth.positive?
+        elsif ch == "," && depth.zero?
+          clauses << current.strip
+          current = +""
+          next
+        end
+        current << ch
+      end
+      clauses << current.strip
+      clauses.reject(&:empty?)
+    end
   end
 end

data/lib/dommy/internal/global_functions.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require "cgi"
+require "erb"
+
+module Dommy
+  module Internal
+    # Stateless global functions exposed on the JS global (Window) that don't
+    # depend on any window state. Kept here so Window doesn't carry the cgi/erb
+    # dependency just for URI component encoding.
+    module GlobalFunctions
+      module_function
+
+      # JS `encodeURIComponent`: percent-encode everything except
+      # `A-Za-z0-9 - _ . ! ~ * ' ( )`. `ERB::Util.url_encode` matches this,
+      # unlike `CGI.escape` (which uses `+` for space).
+      def encode_uri_component(value)
+        ERB::Util.url_encode(value.to_s)
+      end
+
+      def decode_uri_component(value)
+        CGI.unescape(value.to_s)
+      end
+    end
+  end
+end

data/lib/dommy/internal/idna.rb

@@ -87,14 +87,21 @@ module Dommy
       end
 
       # `domain` → ASCII-only form. Returns nil for nil input.
-      def self.to_ascii(domain)
+      #
+      # `check_hyphens` / `verify_dns_length` default to the strict
+      # RFC 5891 profile. The WHATWG URL "domain to ASCII" operation
+      # instead runs UTS #46 with CheckHyphens=false and
+      # VerifyDnsLength=false (so leading/trailing/3-4 hyphens, empty
+      # labels, and over-long labels/domains are all permitted); the
+      # URL parser passes both as false.
+      def self.to_ascii(domain, check_hyphens: true, verify_dns_length: true)
         return domain if domain.nil?
 
         mapped = uts46_map(domain.to_s)
         normalized = mapped.unicode_normalize(:nfc)
         labels = normalized.split(".", -1)
 
-        validate_no_empty_intermediate(labels)
+        validate_no_empty_intermediate(labels) if verify_dns_length
         bidi_domain = labels.any? { |l| bidi_label?(l) }
 
         encoded = labels.map do |label|
@@ -111,13 +118,15 @@ module Dommy
             validate_a_label_roundtrip(label, decoded)
           end
 
-          validate_label(decoded, bidi_domain: bidi_domain)
+          validate_label(decoded, bidi_domain: bidi_domain, check_hyphens: check_hyphens)
           encode_label(decoded)
         end
 
-        encoded.each { |label| validate_a_label_form(label) }
+        if verify_dns_length
+          encoded.each { |label| validate_a_label_form(label) }
+        end
         result = encoded.join(".")
-        validate_total_length(result)
+        validate_total_length(result) if verify_dns_length
         result
       end
 
@@ -165,10 +174,10 @@ module Dommy
 
       # --- Step 5: validate per-label ---------------------------------
 
-      def self.validate_label(label, bidi_domain:)
+      def self.validate_label(label, bidi_domain:, check_hyphens: true)
         return if label.empty?
 
-        validate_hyphens(label)
+        validate_hyphens(label) if check_hyphens
         validate_no_leading_combining_mark(label)
         check_contextj(label)
         check_contexto(label)

data/lib/dommy/internal/ipv4_parser.rb

@@ -63,15 +63,30 @@ module Dommy
       end
 
       def self.parse_number(str)
-        return 0 if str == "0"
+        return nil if str.empty?
 
-        if str.match?(/\A0[xX][0-9a-fA-F]+\z/)
-          str[2..].to_i(16)
-        elsif str.match?(/\A0[0-7]+\z/)
-          str.to_i(8)
-        elsif str.match?(/\A[1-9][0-9]*\z/)
-          str.to_i
+        radix = 10
+        digits = str
+        if str.length >= 2 && (str[0, 2] == "0x" || str[0, 2] == "0X")
+          radix = 16
+          digits = str[2..]
+        elsif str.length >= 2 && str[0] == "0"
+          radix = 8
+          digits = str[1..]
         end
+
+        # A bare radix prefix (`0x`, `0`) denotes the number 0.
+        return 0 if digits.empty?
+
+        valid =
+          case radix
+          when 16 then digits.match?(/\A[0-9a-fA-F]+\z/)
+          when 8 then digits.match?(/\A[0-7]+\z/)
+          else digits.match?(/\A[0-9]+\z/)
+          end
+        return nil unless valid
+
+        digits.to_i(radix)
       end
     end
   end

data/lib/dommy/internal/mutation_coordinator.rb

@@ -109,7 +109,13 @@ module Dommy
           previous_sibling: prev_w,
           next_sibling: next_w
         )
+        # Only observers whose matching registration requested childList get the
+        # record (an `attributes`/`characterData`-only observer must not — e.g.
+        # `observe(t, {childList: false, attributes: true})`).
         @observer_manager.observers_matching(target).each do |observer|
+          entry = observer.find_matching_entry(target)
+          next unless entry && entry[:child_list]
+
           observer.enqueue(record)
         end
 
@@ -117,11 +123,13 @@ module Dommy
       end
 
       # Fire MutationObserver attribute records
-      def notify_attribute_mutation(target_node:, attribute_name:, old_value:)
+      def notify_attribute_mutation(target_node:, attribute_name:, old_value:, namespace: nil)
         target = @document.wrap_node(target_node)
         return nil unless target
 
-        attr = attribute_name.to_s.downcase
+        # A namespaced attribute keeps its local name as-is; a plain HTML
+        # attribute is lower-cased.
+        attr = namespace ? attribute_name.to_s : attribute_name.to_s.downcase
         new_value = target_node[attr]
 
         # Custom Element attributeChangedCallback (synchronous)
@@ -139,6 +147,7 @@ module Dommy
               type: "attributes",
               target: target,
               attribute_name: attr,
+              attribute_namespace: namespace,
               old_value: entry[:attribute_old_value] ? old_value : nil
             )
           )

data/lib/dommy/internal/namespaces.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module Dommy
+  module Internal
+    # Namespace constants and the WHATWG DOM "validate and extract" algorithm,
+    # shared by createAttributeNS / setAttributeNS / createElementNS.
+    module Namespaces
+      HTML  = "http://www.w3.org/1999/xhtml"
+      SVG   = "http://www.w3.org/2000/svg"
+      MATHML = "http://www.w3.org/1998/Math/MathML"
+      XML   = "http://www.w3.org/XML/1998/namespace"
+      XLINK = "http://www.w3.org/1999/xlink"
+      XMLNS = "http://www.w3.org/2000/xmlns/"
+
+      # XML Name / QName productions, matching the canonical
+      # `xml-name-validator` package (what WHATWG DOM "validate" relies on).
+      # Built from the XML 1.0 NameStartChar / NameChar Unicode ranges; an
+      # NCName excludes ":", a QName is one optional `prefix:` + local NCName.
+      NC_START = "A-Za-z_\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02FF\\u0370-\\u037D" \
+                 "\\u037F-\\u1FFF\\u200C-\\u200D\\u2070-\\u218F\\u2C00-\\u2FEF" \
+                 "\\u3001-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFFD\\u{10000}-\\u{EFFFF}"
+      NC_EXTRA = "\\-.0-9\\u00B7\\u0300-\\u036F\\u203F-\\u2040"
+      NCSTART  = "[#{NC_START}]"
+      NCCHAR   = "[#{NC_START}#{NC_EXTRA}]"
+
+      # The full Name production (NameStartChar additionally includes ":").
+      NAME  = Regexp.new("\\A[:#{NC_START}][:#{NC_START}#{NC_EXTRA}]*\\z")
+      # PrefixedName | UnprefixedName.
+      QNAME = Regexp.new(
+        "(?:\\A#{NCSTART}#{NCCHAR}*:#{NCSTART}#{NCCHAR}*\\z)|(?:\\A#{NCSTART}#{NCCHAR}*\\z)"
+      )
+
+      module_function
+
+      # https://dom.spec.whatwg.org/#validate-and-extract
+      # Returns [namespace_or_nil, prefix_or_nil, local_name]. Raises
+      # DOMException (InvalidCharacterError / NamespaceError) on bad input.
+      def validate_and_extract(namespace, qualified_name)
+        ns = namespace.to_s
+        ns = nil if ns.empty?
+        qname = qualified_name.to_s
+
+        unless qname.match?(QNAME)
+          raise DOMException::InvalidCharacterError, "invalid qualified name: #{qname.inspect}"
+        end
+
+        prefix = nil
+        local = qname
+        if qname.include?(":")
+          prefix, local = qname.split(":", 2)
+        end
+
+        if prefix && ns.nil?
+          raise DOMException::NamespaceError, "prefix #{prefix.inspect} with null namespace"
+        end
+        if prefix == "xml" && ns != XML
+          raise DOMException::NamespaceError, "prefix 'xml' must use the XML namespace"
+        end
+        if (qname == "xmlns" || prefix == "xmlns") && ns != XMLNS
+          raise DOMException::NamespaceError, "'xmlns' must use the XMLNS namespace"
+        end
+        if ns == XMLNS && qname != "xmlns" && prefix != "xmlns"
+          raise DOMException::NamespaceError, "the XMLNS namespace requires the 'xmlns' name/prefix"
+        end
+
+        [ns, prefix, local]
+      end
+    end
+  end
+end

data/lib/dommy/internal/node_equality.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module Dommy
+  module Internal
+    # WHATWG DOM "equals" / Node.isEqualNode (https://dom.spec.whatwg.org/#concept-node-equals).
+    # Operates on Dommy node wrappers through their bridge-facing accessors
+    # (__js_get__ for the per-type data, #child_nodes / #attributes for the
+    # structure), so it works uniformly across the heterogeneous node classes.
+    module NodeEquality
+      module_function
+
+      def equal?(a, b)
+        return false if b.nil?
+
+        type = prop(a, "nodeType")
+        return false unless type == prop(b, "nodeType")
+        return false unless data_equal?(a, b, type)
+
+        kids_a = children(a)
+        kids_b = children(b)
+        return false unless kids_a.length == kids_b.length
+
+        kids_a.each_index { |i| return false unless equal?(kids_a[i], kids_b[i]) }
+        true
+      end
+
+      # Per-type "these two nodes have equal own properties" (children compared
+      # separately by #equal?).
+      def data_equal?(a, b, type)
+        case type
+        when Node::ELEMENT_NODE
+          prop(a, "namespaceURI") == prop(b, "namespaceURI") &&
+            prop(a, "prefix") == prop(b, "prefix") &&
+            prop(a, "localName") == prop(b, "localName") &&
+            attributes_equal?(a, b)
+        when Node::DOCUMENT_TYPE_NODE
+          prop(a, "nodeName") == prop(b, "nodeName") &&
+            prop(a, "publicId") == prop(b, "publicId") &&
+            prop(a, "systemId") == prop(b, "systemId")
+        when Node::PROCESSING_INSTRUCTION_NODE
+          prop(a, "target") == prop(b, "target") && prop(a, "data") == prop(b, "data")
+        when Node::TEXT_NODE, Node::CDATA_SECTION_NODE, Node::COMMENT_NODE
+          prop(a, "data") == prop(b, "data")
+        when Node::ATTRIBUTE_NODE
+          prop(a, "namespaceURI") == prop(b, "namespaceURI") &&
+            prop(a, "localName") == prop(b, "localName") &&
+            prop(a, "value") == prop(b, "value")
+        else
+          # Document / DocumentFragment carry no own properties to compare.
+          true
+        end
+      end
+
+      # Equal attribute lists, order-independent (each attribute of A must have
+      # a (namespace, localName, value) match in B, and the counts must match).
+      def attributes_equal?(a, b)
+        attrs_a = attribute_descriptors(a)
+        attrs_b = attribute_descriptors(b)
+        return false unless attrs_a.length == attrs_b.length
+
+        attrs_a.all? { |x| attrs_b.include?(x) }
+      end
+
+      def attribute_descriptors(node)
+        return [] unless node.respond_to?(:attributes)
+
+        map = node.attributes
+        (0...map.length).map do |i|
+          attr = map.item(i)
+          [attr.namespace_uri, attr.local_name, attr.value]
+        end
+      end
+
+      def children(node)
+        return [] unless node.respond_to?(:child_nodes)
+
+        list = node.child_nodes
+        list.respond_to?(:to_a) ? list.to_a : (0...list.length).map { |i| list.item(i) }
+      end
+
+      def prop(node, key)
+        node.__js_get__(key)
+      end
+    end
+  end
+end

data/lib/dommy/internal/node_wrapper_cache.rb

@@ -6,8 +6,6 @@ module Dommy
     # Ensures that wrap_node(nokogiri_node) always returns the same Ruby object.
     # Separates identity/caching management from Document's public DOM API.
     class NodeWrapperCache
-      NAME_RE = /\A[a-z][\w.\-]*\z/i
-
       def initialize(document)
         @document = document
         @wrappers = {}
@@ -29,17 +27,36 @@ module Dommy
       # Factory methods
 
       def create_element(name)
-        str = name.to_s
+        str = domstring(name)
         raise DOMException::InvalidCharacterError, "name must not be empty" if str.empty?
-        raise DOMException::InvalidCharacterError, "invalid element name: #{str.inspect}" unless str.match?(NAME_RE)
+        raise DOMException::InvalidCharacterError, "invalid element name: #{str.inspect}" unless str.match?(Namespaces::NAME)
+
+        # WHATWG createElement: lowercase (ASCII) the name only in an HTML
+        # document; the namespace is the HTML namespace for HTML/XHTML documents
+        # and null for a non-XHTML XML document. Record the metadata so the
+        # element's localName/tagName/namespaceURI getters report it faithfully
+        # (in particular case preservation for XML/XHTML).
+        if @document.html_document?
+          local = str.downcase(:ascii)
+          namespace = Element::HTML_NAMESPACE
+        else
+          local = str
+          namespace = @document.content_type == "application/xhtml+xml" ? Element::HTML_NAMESPACE : nil
+        end
 
-        wrap_node(Backend.create_element(str.downcase, @document.nokogiri_doc))
+        wrapper = wrap_node(Backend.create_element(local, @document.nokogiri_doc))
+        wrapper.__internal_set_namespace__(namespace, nil, local, local)
+        wrapper
       end
 
       def create_text_node(text)
         wrap_node(Backend.create_text(text.to_s, @document.nokogiri_doc))
       end
 
+      def create_cdata_section(text)
+        wrap_node(Backend.create_cdata(text.to_s, @document.nokogiri_doc))
+      end
+
       def create_comment(text)
         wrap_node(Backend.create_comment(text.to_s, @document.nokogiri_doc))
       end
@@ -49,46 +66,52 @@ module Dommy
       end
 
       def create_attribute(name)
-        str = name.to_s
+        str = domstring(name)
         raise DOMException::InvalidCharacterError, "name must not be empty" if str.empty?
-        raise DOMException::InvalidCharacterError, "invalid attribute name: #{str.inspect}" unless str.match?(NAME_RE)
+        raise DOMException::InvalidCharacterError, "invalid attribute name: #{str.inspect}" unless str.match?(Namespaces::NAME)
 
         Attr.new(str)
       end
 
-      def create_attribute_ns(_namespace_uri, qualified_name)
-        str = qualified_name.to_s
-        raise DOMException::InvalidCharacterError, "name must not be empty" if str.empty?
-        raise DOMException::InvalidCharacterError, "invalid qualified name: #{str.inspect}" unless str.match?(NAME_RE)
-
-        Attr.new(str)
+      def create_attribute_ns(namespace_uri, qualified_name)
+        namespace_uri = nil if namespace_uri.equal?(Bridge::UNDEFINED)
+        qualified_name = domstring(qualified_name)
+        ns, prefix, local = Namespaces.validate_and_extract(namespace_uri, qualified_name)
+        Attr.new(qualified_name, namespace_uri: ns, prefix: prefix, local_name: local)
       end
 
       def create_element_ns(namespace_uri, qualified_name)
-        str = qualified_name.to_s
-        raise DOMException::InvalidCharacterError, "name must not be empty" if str.empty?
-        raise DOMException::InvalidCharacterError, "invalid qualified name: #{str.inspect}" unless str.match?(NAME_RE)
-
-        el = Backend.create_element(str, @document.nokogiri_doc)
-        if namespace_uri && !namespace_uri.to_s.empty?
-          Backend.add_namespace_definition(el, nil, namespace_uri.to_s)
-        end
-
-        wrap(el)
+        # WHATWG "validate and extract": QName-validate the qualifiedName
+        # (InvalidCharacterError) and apply the prefix/namespace rules
+        # (NamespaceError), then build the element with its prefix bound.
+        # namespace is nullable (undefined → null); qualifiedName is a plain
+        # DOMString (undefined → "undefined", null → "null").
+        namespace_uri = nil if namespace_uri.equal?(Bridge::UNDEFINED)
+        qualified_name = domstring(qualified_name)
+        ns, prefix, local = Namespaces.validate_and_extract(namespace_uri, qualified_name)
+
+        el = Backend.create_element(qualified_name, @document.nokogiri_doc)
+        Backend.add_namespace_definition(el, prefix, ns) if ns
+
+        wrapper = wrap(el)
+        wrapper.__internal_set_namespace__(ns, prefix, local, qualified_name)
+        wrapper
       end
 
       # Query methods
 
       def query_selector(selector)
-        return nil if selector.nil? || selector.to_s.empty?
+        return nil if selector.nil?
+        Internal.validate_selector!(selector)
 
-        wrap(@document.nokogiri_doc.at_css(selector.to_s, CSS_PSEUDO_HANDLERS))
+        wrap(@document.nokogiri_doc.at_css(Internal.backend_safe_selector(selector.to_s), CSS_PSEUDO_HANDLERS))
       end
 
       def query_selector_all(selector)
-        return NodeList.new if selector.nil? || selector.to_s.empty?
+        return NodeList.new if selector.nil?
+        Internal.validate_selector!(selector)
 
-        NodeList.new(@document.nokogiri_doc.css(selector.to_s, CSS_PSEUDO_HANDLERS).map { |node| wrap(node) }.compact)
+        NodeList.new(@document.nokogiri_doc.css(Internal.backend_safe_selector(selector.to_s), CSS_PSEUDO_HANDLERS).map { |node| wrap(node) }.compact)
       end
 
       def get_element_by_id(id)
@@ -144,6 +167,15 @@ module Dommy
 
       private
 
+      # WebIDL DOMString coercion for a name/qualifiedName argument: JS
+      # `undefined` → "undefined", JS `null` (Ruby nil) → "null", else #to_s.
+      def domstring(value)
+        return "undefined" if value.equal?(Bridge::UNDEFINED)
+        return "null" if value.nil?
+
+        value.to_s
+      end
+
       def wrap_node(node)
         wrap(node)
       end
@@ -152,6 +184,9 @@ module Dommy
         case node
         when Backend.element_class
           build_element_wrapper(node)
+        when ->(n) { Backend.cdata_class && n.is_a?(Backend.cdata_class) }
+          # CDATA is a Text subtype in the backend, so match it before text_class.
+          CDATASectionNode.new(@document, node)
         when Backend.text_class
           TextNode.new(@document, node)
         when Backend.comment_class

data/lib/dommy/internal/observable_callback.rb

@@ -14,11 +14,7 @@ module Dommy
       private
 
       def invoke_callback(entries)
-        if @callback.respond_to?(:__js_call__)
-          @callback.__js_call__("call", [entries, self])
-        elsif @callback.respond_to?(:call)
-          @callback.call(entries, self)
-        end
+        CallableInvoker.invoke(@callback, entries, self)
       end
     end
   end