markbridge 0.1.2 → 0.2.0

data/lib/markbridge/parsers/media_wiki/inline_parser.rb

@@ -11,13 +11,20 @@ module Markbridge
       #   registry = InlineTagRegistry.build_from_default do |r|
       #     r.register("mark", :formatting, AST::Bold)
       #   end
-      #   parser = InlineParser.new(inline_tag_registry: registry)
+      #   parser = InlineParser.new(handlers: registry)
       class InlineParser
         MAX_INLINE_DEPTH = 20
 
-        def initialize(inline_tag_registry: nil, depth: 0)
-          @registry = inline_tag_registry || InlineTagRegistry.default
+        # @return [Hash{String => Integer}] tag-name → occurrence count for
+        #   HTML-like inline tags whose names are not registered. Shared
+        #   with nested InlineParser instances so depth-recursive parses
+        #   contribute to the same tally.
+        attr_reader :unknown_tags
+
+        def initialize(handlers: nil, depth: 0, unknown_tags: nil)
+          @registry = handlers || InlineTagRegistry.default
           @depth = depth
+          @unknown_tags = unknown_tags || Hash.new(0)
         end
 
         # Parse inline markup and append resulting AST nodes to the parent element.
@@ -110,10 +117,11 @@ module Markbridge
             return
           end
 
-          InlineParser.new(inline_tag_registry: @registry, depth: @depth + 1).parse(
-            content,
-            parent:,
-          )
+          InlineParser.new(
+            handlers: @registry,
+            depth: @depth + 1,
+            unknown_tags: @unknown_tags,
+          ).parse(content, parent:)
         end
 
         # Collect text until we find n consecutive apostrophes.
@@ -203,9 +211,14 @@ module Markbridge
           self_closing = !tag_match[3].empty?
           tag_name = tag_match[2].downcase
 
-          # Closing/self-closing tags and unknown tags are treated as literal text
+          # Closing/self-closing tags and unknown tags are treated as literal text.
+          # Track *unknown* opening tags so callers can surface them via
+          # Parse/Conversion#unknown_tags. We deliberately don't track
+          # closing/self-closing forms — they often pair up with the
+          # opening tag that's already counted.
           entry = @registry[tag_name]
           if closing || self_closing || !entry
+            @unknown_tags[tag_name] += 1 if !entry && !closing && !self_closing
             advance_as_text(full_match)
             return
           end

data/lib/markbridge/parsers/media_wiki/parser.rb

@@ -21,13 +21,20 @@ module Markbridge
       #   parser = Markbridge::Parsers::MediaWiki::Parser.new
       #   ast = parser.parse("'''bold''' and ''italic''")
       class Parser
-        # @param inline_tag_registry [InlineTagRegistry, nil] custom registry or use default
+        # @return [Hash{String => Integer}] tag-name → occurrence count for
+        #   inline HTML-like tags whose names are not registered. Reset at
+        #   the start of every #parse call.
+        attr_reader :unknown_tags
+
+        # @param handlers [InlineTagRegistry, nil] custom registry or use default.
+        #   Named +handlers:+ for consistency with sibling parsers; the
+        #   value is still an +InlineTagRegistry+ instance.
         # @yield [InlineTagRegistry] optional block to customize the default registry
-        def initialize(inline_tag_registry: nil, &block)
+        def initialize(handlers: nil, &block)
           # InlineParser falls back to InlineTagRegistry.default when this is
           # nil, so we don't need to materialise it here.
-          @inline_tag_registry =
-            block_given? ? InlineTagRegistry.build_from_default(&block) : inline_tag_registry
+          @handlers = block_given? ? InlineTagRegistry.build_from_default(&block) : handlers
+          @unknown_tags = Hash.new(0)
         end
 
         # Parse MediaWiki wikitext into an AST Document.
@@ -38,8 +45,9 @@ module Markbridge
           normalized = normalize_line_endings(input)
           lines = normalized.split("\n")
 
+          @unknown_tags.clear
           @document = AST::Document.new
-          @inline_parser = InlineParser.new(inline_tag_registry: @inline_tag_registry)
+          @inline_parser = InlineParser.new(handlers: @handlers, unknown_tags: @unknown_tags)
           @list_stack = []
 
           process_lines(lines)

data/lib/markbridge/parsers/text_formatter/handler_registry.rb

@@ -43,6 +43,28 @@ module Markbridge
           @mappings[element_name.upcase] = handler
         end
 
+        # Look up the handler for an element name (case-insensitive).
+        # @param element_name [String]
+        # @return [#process, nil]
+        def [](element_name)
+          @mappings[element_name.upcase]
+        end
+
+        # Replace the handler bound to one or more element names by
+        # yielding the previously-bound handler (which may be +nil+)
+        # and registering whatever the block returns.
+        #
+        # @param element_names [String, Array<String>]
+        # @yieldparam previous [#process, nil]
+        # @return [self]
+        def overlay(element_names)
+          Array(element_names).each do |name|
+            previous = self[name]
+            register(name, yield(previous))
+          end
+          self
+        end
+
         # Check if a handler is registered for an element
         # @param element_name [String] XML element name
         # @return [Boolean] true if handler is registered
@@ -53,11 +75,12 @@ module Markbridge
         # Process an XML element using the registered handler
         # @param element [Nokogiri::XML::Element]
         # @param parent [AST::Element] parent node to add children to
+        # @param processor [Parser] the parser, exposed to handlers so
+        #   they can call back into +process_children+ for nested content
         # @return [AST::Element, nil] the created element if children should be processed, nil otherwise
-        def process_element(element, parent)
-          tag_name = element.name.upcase
-          handler = @mappings[tag_name]
-          handler&.process(element:, parent:)
+        def process_element(element, parent, processor)
+          handler = self[element.name]
+          handler&.process(element:, parent:, processor:)
         end
 
         # Register all default s9e/TextFormatter element mappings

data/lib/markbridge/parsers/text_formatter/handlers/attachment_handler.rb

@@ -10,7 +10,7 @@ module Markbridge
             @element_class = AST::Attachment
           end
 
-          def process(element:, parent:)
+          def process(element:, parent:, processor: nil)
             attrs = extract_attributes(element)
             node =
               AST::Attachment.new(

data/lib/markbridge/parsers/text_formatter/handlers/attribute_handler.rb

@@ -23,7 +23,7 @@ module Markbridge
             @param = param || attribute
           end
 
-          def process(element:, parent:)
+          def process(element:, parent:, processor: nil)
             attrs = extract_attributes(element)
             node = @element_class.new(@param => attrs[@attribute])
             parent << node

data/lib/markbridge/parsers/text_formatter/handlers/base_handler.rb

@@ -16,7 +16,7 @@ module Markbridge
           # @param element [Nokogiri::XML::Element] the XML element to process
           # @param parent [AST::Element] the parent AST node to add children to
           # @return [AST::Element, nil] the created element if children should be processed, nil otherwise
-          def process(element:, parent:)
+          def process(element:, parent:, processor: nil)
             raise NotImplementedError, "#{self.class} must implement #process"
           end
 

data/lib/markbridge/parsers/text_formatter/handlers/code_handler.rb

@@ -10,7 +10,7 @@ module Markbridge
             @element_class = AST::Code
           end
 
-          def process(element:, parent:)
+          def process(element:, parent:, processor: nil)
             attrs = extract_attributes(element)
             lang = attrs[:lang] || attrs[:language]
             node = AST::Code.new(language: lang)

data/lib/markbridge/parsers/text_formatter/handlers/email_handler.rb

@@ -10,7 +10,7 @@ module Markbridge
             @element_class = AST::Email
           end
 
-          def process(element:, parent:)
+          def process(element:, parent:, processor: nil)
             attrs = extract_attributes(element)
             node = AST::Email.new(address: attrs[:email])
             parent << node

data/lib/markbridge/parsers/text_formatter/handlers/image_handler.rb

@@ -10,7 +10,7 @@ module Markbridge
             @element_class = AST::Image
           end
 
-          def process(element:, parent:)
+          def process(element:, parent:, processor: nil)
             attrs = extract_attributes(element)
             node =
               AST::Image.new(

data/lib/markbridge/parsers/text_formatter/handlers/list_handler.rb

@@ -10,7 +10,7 @@ module Markbridge
             @element_class = AST::List
           end
 
-          def process(element:, parent:)
+          def process(element:, parent:, processor: nil)
             attrs = extract_attributes(element)
             type_str = attrs[:type]
             # Ordered if type is not empty, disc, circle, or square

data/lib/markbridge/parsers/text_formatter/handlers/quote_handler.rb

@@ -10,7 +10,7 @@ module Markbridge
             @element_class = AST::Quote
           end
 
-          def process(element:, parent:)
+          def process(element:, parent:, processor: nil)
             attrs = extract_attributes(element)
             node =
               AST::Quote.new(

data/lib/markbridge/parsers/text_formatter/handlers/simple_handler.rb

@@ -21,7 +21,7 @@ module Markbridge
           # Process the element by creating an AST node and processing children
           # @param element [Nokogiri::XML::Element]
           # @param parent [AST::Element]
-          def process(element:, parent:)
+          def process(element:, parent:, processor: nil)
             node = @element_class.new
             parent << node
 

data/lib/markbridge/parsers/text_formatter/handlers/table_cell_handler.rb

@@ -10,7 +10,7 @@ module Markbridge
             @element_class = AST::TableCell
           end
 
-          def process(element:, parent:)
+          def process(element:, parent:, processor: nil)
             node = AST::TableCell.new(header: element.name.upcase == "TH")
             parent << node
             node

data/lib/markbridge/parsers/text_formatter/handlers/url_handler.rb

@@ -12,7 +12,7 @@ module Markbridge
             @element_class = AST::Url
           end
 
-          def process(element:, parent:)
+          def process(element:, parent:, processor: nil)
             attrs = extract_attributes(element)
             node = AST::Url.new(href: attrs[:url])
             parent << node

data/lib/markbridge/parsers/text_formatter/parser.rb

@@ -38,12 +38,26 @@ module Markbridge
           @unknown_tags = Hash.new(0)
         end
 
-        # Parse s9e/TextFormatter XML into an AST
-        # @param input [String] XML string in s9e/TextFormatter format
+        # Parse s9e/TextFormatter XML into an AST.
+        #
+        # Accepts either a String of XML or a pre-parsed Nokogiri node.
+        # A +Nokogiri::XML::Document+ is unwrapped via +#root+; any
+        # other node is treated as the root itself.
+        #
+        # @param input [String, Nokogiri::XML::Node] XML source or
+        #   pre-parsed Nokogiri tree
         # @return [AST::Document]
         def parse(input)
           @unknown_tags.clear
 
+          if input.is_a?(Nokogiri::XML::Node)
+            root = input.is_a?(Nokogiri::XML::Document) ? input.root : input
+            document = AST::Document.new
+            process_node(root, document) if root
+            return document
+          end
+
+          input = input.to_s
           xml_doc = Nokogiri.XML(input)
           root = xml_doc.root
 
@@ -101,7 +115,7 @@ module Markbridge
 
           # Process element with registered handler
           # Handler returns element if children should be processed, nil otherwise
-          result_element = @handlers.process_element(element, ast_parent)
+          result_element = @handlers.process_element(element, ast_parent, self)
 
           if result_element
             # Handler succeeded and returned element - process children into it

data/lib/markbridge/renderers/discourse/identity_escaper.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Markbridge
+  module Renderers
+    module Discourse
+      # Pass-through escaper. Returns its input unchanged.
+      #
+      # Useful for migration paths where the source content is already
+      # valid Markdown (or otherwise trusted not to need escaping) and
+      # should reach the postprocessor verbatim. For *partial*
+      # passthrough (e.g. allow lists but still escape headings), see
+      # {MarkdownEscaper#initialize}'s +allow:+ kwarg.
+      #
+      # @example Per-call use via the renderer factory
+      #   renderer = Markbridge.discourse_renderer(escape: false)
+      #   Markbridge.bbcode_to_markdown(post.body, renderer:)
+      class IdentityEscaper
+        # @param text [String, nil]
+        # @param in_link_label [Boolean] when true, escape +]+ so the
+        #   text can be spliced into a Markdown link label
+        #   +[text](url)+ without terminating it early. Mirrors
+        #   {MarkdownEscaper#escape}'s +in_link_label:+. This isn't a
+        #   stylistic escape — without it, trusted-Markdown content
+        #   containing +]+ inside a +Url+/+Email+ ancestor produces a
+        #   broken link.
+        # @return [String] +text+ with +]+ optionally escaped, or
+        #   +""+ when +text+ is nil
+        def escape(text, in_link_label: false)
+          return "" if text.nil?
+          return text.gsub("]", "\\]") if in_link_label && text.include?("]")
+
+          text
+        end
+      end
+    end
+  end
+end

data/lib/markbridge/renderers/discourse/markdown_escaper.rb

@@ -30,12 +30,29 @@ module Markbridge
       #   escaper.escape("<?php echo 1; ?>")    # => "\\<?php echo 1; ?>"
       #
       class MarkdownEscaper
+        # Block-level constructs that callers can opt into letting
+        # through unescaped via the +allow:+ kwarg. The check fires
+        # only after a line's first byte has matched the relevant
+        # case arm, so this is a cold-path lookup with no measurable
+        # hot-path cost.
+        ALLOW_KEYS = %i[bullet_list ordered_list atx_heading block_quote].freeze
+        ALLOW_ALIASES = { lists: %i[bullet_list ordered_list] }.freeze
+        private_constant :ALLOW_KEYS, :ALLOW_ALIASES
+
         # @param escape_hard_line_breaks [Boolean] when true, strip trailing spaces
         #   before newlines to prevent CommonMark hard line breaks (<br/>).
         #   Defaults to false because Discourse has trailing-space hard line
         #   breaks disabled by default.
-        def initialize(escape_hard_line_breaks: false)
+        # @param allow [Symbol, Array<Symbol>, nil] block-level constructs
+        #   to pass through unescaped. Recognised keys:
+        #   +:bullet_list+, +:ordered_list+, +:atx_heading+,
+        #   +:block_quote+. The alias +:lists+ expands to
+        #   `[:bullet_list, :ordered_list]`. Thematic breaks, setext
+        #   underlines, fenced code, and indented code remain escaped
+        #   even when their first byte matches an allow-listed marker.
+        def initialize(escape_hard_line_breaks: false, allow: nil)
           @escape_hard_line_breaks = escape_hard_line_breaks
+          @allow = resolve_allow(allow)
           # @inline_content / @inline_result / @inline_len are set by
           # escape_inline on every call before any helper reads them;
           # no defensive init needed.
@@ -116,23 +133,59 @@ module Markbridge
         # Autolinks (<https://...>, <email@domain>) are intentionally preserved.
         #
         # @param text [String, nil] the text to escape
+        # @param in_link_label [Boolean] when true, also escape `]` so the text
+        #   can be spliced into a Markdown link label `[text](url)` without
+        #   terminating it early. The default leaves `]` alone because a bare
+        #   `]` in prose is harmless (the matching `[` is already escaped).
         # @return [String] the escaped text, or empty string if input is nil
         # @note Multi-line HTML tags and blocks are handled by escaping the opening <
-        def escape(text)
+        def escape(text, in_link_label: false)
           return "" if text.nil?
 
           # Neutralize hard line breaks (trailing 2+ spaces before newline)
           text = text.gsub(/  +\n/, "\n") if @escape_hard_line_breaks && text.include?("  \n")
 
-          return text unless MAYBE_SPECIAL.match?(text) || MAYBE_INDENTED_CODE.match?(text)
+          result =
+            if MAYBE_SPECIAL.match?(text) || MAYBE_INDENTED_CODE.match?(text)
+              escape_text(text)
+            else
+              text
+            end
+
+          return result unless in_link_label && result.include?("]")
 
-          escape_text(text)
+          result.gsub("]") { "\\]" }
         end
 
         private
 
+        def resolve_allow(allow)
+          # `flat_map` flattens Array results and appends scalar
+          # results as-is, so `|| key` keeps non-alias keys without
+          # extra wrapping.
+          keys = Array(allow).flat_map { |key| ALLOW_ALIASES[key] || key }
+          unknown = keys - ALLOW_KEYS
+          unless unknown.empty?
+            raise ArgumentError,
+                  "unknown allow keys: #{unknown.inspect} " \
+                    "(expected #{ALLOW_KEYS.inspect} or alias #{ALLOW_ALIASES.keys.inspect})"
+          end
+          # Array, not Set: with at most 4 keys the linear `include?`
+          # is observably identical to `Set#include?` and avoids the
+          # Set allocation. The array isn't reachable from outside
+          # the escaper, so we don't bother freezing it.
+          keys
+        end
+
         def escape_text(text)
-          lines = text.split("\n", -1)
+          # On CRLF input, consume `\r` as part of the line terminator instead
+          # of leaving it on the line. A trailing `\r` breaks line-end anchored
+          # regexes (e.g. SETEXT_UNDERLINE_*) and the `ws_end >= line_length`
+          # early-out in escape_indented_code, leaking NBSPs onto
+          # whitespace-only CRLF lines. The `include?` guard keeps the
+          # LF-only fast path on a string split (regex split is ~20% slower
+          # on the indented-code hot path).
+          lines = text.include?("\r") ? text.split(/\r?\n/, -1) : text.split("\n", -1)
           return escape_line(lines[0], false) if lines.size == 1
 
           # Pre-allocate result buffer
@@ -217,13 +270,20 @@ module Markbridge
 
           case first_byte
           when HASH
-            return escape_first_char_inline(content, "\\#") if ATX_HEADING.match?(content)
+            if (match = ATX_HEADING.match(content))
+              return pass_marker_inline(content, match[0].length) if @allow.include?(:atx_heading)
+              return escape_first_char_inline(content, "\\#")
+            end
           when GT
+            return pass_first_char_inline(content) if @allow.include?(:block_quote)
             return escape_first_char_inline(content, "\\>")
           when DASH
             return escape_block_dash(content, prev_was_paragraph)
           when PLUS
-            return escape_first_char_inline(content, "\\+") if BULLET_LIST.match?(content)
+            if BULLET_LIST.match?(content)
+              return pass_first_char_inline(content) if @allow.include?(:bullet_list)
+              return escape_first_char_inline(content, "\\+")
+            end
           when STAR
             return escape_block_star(content)
           when UNDERSCORE
@@ -261,24 +321,46 @@ module Markbridge
                (prev_was_paragraph && SETEXT_UNDERLINE_DASH.match?(content))
             return escape_all_chars(content, DASH, "\\-"), true
           end
-          return escape_first_char_inline(content, "\\-") if BULLET_LIST.match?(content)
+          if BULLET_LIST.match?(content)
+            return pass_first_char_inline(content) if @allow.include?(:bullet_list)
+            return escape_first_char_inline(content, "\\-")
+          end
           [content, false]
         end
 
         def escape_block_star(content)
           return escape_all_chars(content, STAR, "\\*"), true if THEMATIC_BREAK_STAR.match?(content)
-          return escape_first_char_inline(content, "\\*") if BULLET_LIST.match?(content)
+          if BULLET_LIST.match?(content)
+            return pass_first_char_inline(content) if @allow.include?(:bullet_list)
+            return escape_first_char_inline(content, "\\*")
+          end
           [content, false]
         end
 
         def escape_block_ordered_list(content)
           if (match = ORDERED_LIST.match(content))
             rest = content[match[0].length..]
+            return pass_marker_inline(content, match[0].length) if @allow.include?(:ordered_list)
+
             return "#{match[1]}\\#{match[2]}#{escape_inline(rest)}", true
           end
           [content, false]
         end
 
+        # Like {#escape_first_char_inline} but the leading character is
+        # preserved verbatim (used when allow: lets a single-byte
+        # marker like `-`, `+`, `*`, or `>` through).
+        def pass_first_char_inline(content)
+          ["#{content[0]}#{escape_inline(content[1..])}", true]
+        end
+
+        # Preserve a multi-byte marker (e.g. `1.`, `99)`, `##`) and
+        # inline-escape the rest. Used when allow: lets ordered lists
+        # or ATX headings through.
+        def pass_marker_inline(content, marker_length)
+          ["#{content[0, marker_length]}#{escape_inline(content[marker_length..])}", true]
+        end
+
         def escape_all_chars(str, byte_val, escaped)
           result = String.new(capacity: str.bytesize * 2, encoding: str.encoding)
           str.each_byte do |byte|

data/lib/markbridge/renderers/discourse/postprocessor.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Markbridge
+  module Renderers
+    module Discourse
+      # Cleans up the raw Markdown produced by the Renderer:
+      #
+      # 1. (optional) strips trailing invisible characters per line —
+      #    NBSP plus the zero-width format chars (ZWSP, ZWNJ, ZWJ, WJ,
+      #    ZWNBSP/BOM). Deliberately excludes ASCII space and tab so
+      #    Markdown's "two trailing spaces = hard line break" rule
+      #    still works. Off by default.
+      # 2. collapses runs of 3+ newlines down to two,
+      # 3. clears whitespace-only lines,
+      # 4. trims leading/trailing whitespace from the whole document.
+      #
+      # Subclass to customize. The +call+ method is the entry point.
+      class Postprocessor
+        # NBSP plus zero-width format chars. Spelled with explicit
+        # +\u{...}+ escapes rather than the literal characters — the
+        # latter are invisible in editors and easy to corrupt on
+        # encoding-conversion round-trips.
+        #
+        #   U+00A0  NBSP        no-break space
+        #   U+200B  ZWSP        zero-width space
+        #   U+200C  ZWNJ        zero-width non-joiner
+        #   U+200D  ZWJ         zero-width joiner
+        #   U+2060  WJ          word joiner
+        #   U+FEFF  ZWNBSP/BOM  zero-width no-break space / byte-order mark
+        TRAILING_INVISIBLE_RE = /[\u{00A0 200B 200C 200D 2060 FEFF}]+$/
+
+        # @param strip_trailing_invisibles [Boolean] when true, strips
+        #   trailing invisible characters (NBSP and zero-width format
+        #   chars) from each line before the standard cleanup pass.
+        def initialize(strip_trailing_invisibles: false)
+          @strip_trailing_invisibles = strip_trailing_invisibles
+        end
+
+        # @param text [String]
+        # @return [String]
+        def call(text)
+          text = text.gsub(TRAILING_INVISIBLE_RE, "") if @strip_trailing_invisibles
+          text
+            .gsub(/\n{3,}/, "\n\n") # Max 2 consecutive newlines
+            .gsub(/^[ \t]+$/, "") # Remove whitespace-only lines
+            .strip # Trim leading/trailing whitespace
+        end
+
+        DEFAULT = new
+      end
+    end
+  end
+end

data/lib/markbridge/renderers/discourse/render_context.rb

@@ -3,43 +3,30 @@
 module Markbridge
   module Renderers
     module Discourse
-      # Immutable context for rendering that wraps the parent chain
-      # Provides query methods to ask about parent elements without
-      # the renderer knowing about specific element types
-      #
-      # Uses a hash-based cache for O(1) parent lookups instead of O(depth) scans
+      # Immutable context for rendering that wraps the parent chain.
+      # Provides query methods to ask about parent elements without the
+      # renderer knowing about specific element types.
       class RenderContext
         attr_reader :parents, :depth
 
-        def initialize(parents = [], parent_cache: nil, html_mode: false)
+        def initialize(parents = [], html_mode: false)
           @parents = parents.freeze
           @depth = parents.size
-          @parent_cache = parent_cache || build_cache(parents)
           @html_mode = html_mode
         end
 
         # Create new context with element added to parent chain.
-        # Incrementally updates the cache (O(1)) instead of rebuilding from
-        # parents (O(depth)) — important for deeply-nested documents.
         # @param element [AST::Element]
         # @return [RenderContext]
         def with_parent(element)
-          new_parents = @parents + [element]
-
-          new_cache = @parent_cache.dup
-          element_class = element.class
-          new_cache[element_class] ||= []
-          new_cache[element_class] = new_cache[element_class] + [element]
-
-          self.class.new(new_parents, parent_cache: new_cache, html_mode: @html_mode)
+          self.class.new(@parents + [element], html_mode: @html_mode)
         end
 
-        # Create new context with html_mode toggled
-        # Preserves parent chain and cache
+        # Create new context with html_mode toggled.
         # @param value [Boolean]
         # @return [RenderContext]
         def with_html_mode(value)
-          self.class.new(@parents, parent_cache: @parent_cache, html_mode: value)
+          self.class.new(@parents, html_mode: value)
         end
 
         # @return [Boolean]
@@ -47,45 +34,32 @@ module Markbridge
           @html_mode
         end
 
-        # Find closest parent of given type
-        # O(1) hash lookup instead of O(depth) scan
+        # Find closest parent that is_a? klass (handles subclasses).
         # @param klass [Class]
         # @return [AST::Element, nil]
         def find_parent(klass)
-          @parent_cache[klass]&.last
+          @parents.reverse_each.find { |parent| parent.is_a?(klass) }
         end
 
-        # Count parents of given type
-        # O(1) instead of O(depth)
+        # Count parents that are is_a? klass (handles subclasses).
         # @param klass [Class]
         # @return [Integer]
         def count_parents(klass)
-          @parent_cache[klass]&.size || 0
+          @parents.count { |parent| parent.is_a?(klass) }
         end
 
-        # Check if parent of type exists
-        # O(1) check
+        # Check if any parent is_a? klass (handles subclasses).
         # @param klass [Class]
         # @return [Boolean]
         def has_parent?(klass)
-          !@parent_cache[klass].nil?
+          @parents.any? { |parent| parent.is_a?(klass) }
         end
 
-        # Check if we're at the root (no parents)
+        # Check if we're at the root (no parents).
         # @return [Boolean]
         def root?
           @depth.zero?
         end
-
-        private
-
-        # Build cache from parents array.
-        # Groups parents by class for fast O(1) lookup.
-        # @param parents [Array<AST::Element>]
-        # @return [Hash{Class => Array<AST::Element>}]
-        def build_cache(parents)
-          parents.group_by(&:class)
-        end
       end
     end
   end