toml-merge 1.0.0 → 2.0.0

data/lib/toml/merge/node_wrapper.rb

@@ -5,13 +5,25 @@ module Toml
     # Wraps tree-sitter nodes with comment associations, line information, and signatures.
     # This provides a unified interface for working with TOML AST nodes during merging.
     #
+    # Inherits common functionality from Ast::Merge::NodeWrapperBase:
+    # - Source context (lines, source, comments)
+    # - Line info extraction
+    # - Basic methods: #type, #text, #signature
+    #
+    # Adds TOML-specific functionality:
+    # - Backend awareness for Citrus/tree-sitter normalization
+    # - Type predicates using NodeTypeNormalizer
+    # - Structural normalization for Citrus backend (pairs as siblings)
+    #
     # @example Basic usage
     #   parser = TreeHaver::Parser.new
-    #   parser.language = TreeHaver::Language.load("toml", path)
-    #   tree = parser.parse_string(nil, source)
+    #   parser.language = TreeHaver::Language.toml
+    #   tree = parser.parse(source)
     #   wrapper = NodeWrapper.new(tree.root_node, lines: source.lines, source: source)
     #   wrapper.signature # => [:table, "section"]
-    class NodeWrapper
+    #
+    # @see Ast::Merge::NodeWrapperBase
+    class NodeWrapper < Ast::Merge::NodeWrapperBase
       class << self
         # Wrap a tree-sitter node, returning nil for nil input.
         #
@@ -20,141 +32,120 @@ module Toml
         # @param source [String, nil] Original source string
         # @param leading_comments [Array<Hash>] Comments before this node
         # @param inline_comment [Hash, nil] Inline comment on the node's line
+        # @param backend [Symbol] The backend used for parsing (:tree_sitter or :citrus)
         # @return [NodeWrapper, nil] Wrapped node or nil if node is nil
-        def wrap(node, lines, source: nil, leading_comments: [], inline_comment: nil)
+        def wrap(node, lines, source: nil, leading_comments: [], inline_comment: nil, backend: :tree_sitter)
           return if node.nil?
 
-          new(node, lines: lines, source: source, leading_comments: leading_comments, inline_comment: inline_comment)
+          new(
+            node,
+            lines: lines,
+            source: source,
+            leading_comments: leading_comments,
+            inline_comment: inline_comment,
+            backend: backend,
+          )
         end
       end
 
-      # @return [TreeHaver::Node] The wrapped tree-sitter node
-      attr_reader :node
-
-      # @return [Array<Hash>] Leading comments associated with this node
-      attr_reader :leading_comments
-
-      # @return [String] The original source string
-      attr_reader :source
-
-      # @return [Hash, nil] Inline/trailing comment on the same line
-      attr_reader :inline_comment
-
-      # @return [Integer] Start line (1-based)
-      attr_reader :start_line
-
-      # @return [Integer] End line (1-based)
-      attr_reader :end_line
+      # @return [Symbol] The backend used for parsing
+      attr_reader :backend
 
-      # @return [Array<String>] Source lines
-      attr_reader :lines
+      # @return [TreeHaver::Node, nil] The document root node for sibling lookups
+      attr_reader :document_root
 
-      # @param node [TreeHaver::Node] tree-sitter node to wrap
-      # @param lines [Array<String>] Source lines for content extraction
-      # @param source [String] Original source string for byte-based text extraction
-      # @param leading_comments [Array<Hash>] Comments before this node
-      # @param inline_comment [Hash, nil] Inline comment on the node's line
-      def initialize(node, lines:, source: nil, leading_comments: [], inline_comment: nil)
-        @node = node
-        @lines = lines
-        @source = source || lines.join("\n")
-        @leading_comments = leading_comments
-        @inline_comment = inline_comment
-
-        # Extract line information from the tree-sitter node (0-indexed to 1-indexed)
-        @start_line = node.start_point.row + 1 if node.respond_to?(:start_point)
-        @end_line = node.end_point.row + 1 if node.respond_to?(:end_point)
-
-        # Handle edge case where end_line might be before start_line
-        @end_line = @start_line if @start_line && @end_line && @end_line < @start_line
+      # Process TOML-specific options (backend, document_root)
+      # @param options [Hash] Additional options
+      def process_additional_options(options)
+        @backend = options.fetch(:backend, :tree_sitter)
+        @document_root = options[:document_root]
       end
 
-      # Generate a signature for this node for matching purposes.
-      # Signatures are used to identify corresponding nodes between template and destination.
-      #
-      # @return [Array, nil] Signature array or nil if not signaturable
-      def signature
-        compute_signature(@node)
-      end
-
-      # Get the node type as a symbol
+      # Get the canonical (normalized) type for this node
       # @return [Symbol]
-      def type
-        @node.type.to_sym
+      def canonical_type
+        NodeTypeNormalizer.canonical_type(@node.type, @backend)
       end
 
-      # Check if this node has a specific type
+      # Check if this node has a specific type (checks both raw and canonical)
       # @param type_name [Symbol, String] Type to check
       # @return [Boolean]
       def type?(type_name)
-        @node.type.to_s == type_name.to_s
+        type_sym = type_name.to_sym
+        @node.type.to_sym == type_sym || canonical_type == type_sym
       end
 
       # Check if this is a TOML table (section)
       # @return [Boolean]
       def table?
-        @node.type.to_s == "table"
+        canonical_type == :table
       end
 
       # Check if this is a TOML array of tables
+      # Uses NodeTypeNormalizer for backend-agnostic type checking.
       # @return [Boolean]
       def array_of_tables?
-        type_str = @node.type.to_s
-        type_str == "array_of_tables" || type_str == "table_array_element"
+        canonical_type == :array_of_tables
       end
 
       # Check if this is a TOML inline table
       # @return [Boolean]
       def inline_table?
-        @node.type.to_s == "inline_table"
+        canonical_type == :inline_table
       end
 
       # Check if this is a TOML array
       # @return [Boolean]
       def array?
-        @node.type.to_s == "array"
+        canonical_type == :array
       end
 
       # Check if this is a TOML string
       # @return [Boolean]
       def string?
-        %w[string basic_string literal_string multiline_basic_string multiline_literal_string].include?(@node.type.to_s)
+        canonical_type == :string
       end
 
       # Check if this is a TOML integer
       # @return [Boolean]
       def integer?
-        @node.type.to_s == "integer"
+        canonical_type == :integer
       end
 
       # Check if this is a TOML float
       # @return [Boolean]
       def float?
-        @node.type.to_s == "float"
+        canonical_type == :float
       end
 
       # Check if this is a TOML boolean
       # @return [Boolean]
       def boolean?
-        @node.type.to_s == "boolean"
+        canonical_type == :boolean
       end
 
       # Check if this is a key-value pair
       # @return [Boolean]
       def pair?
-        @node.type.to_s == "pair"
+        canonical_type == :pair
       end
 
       # Check if this is a comment
       # @return [Boolean]
       def comment?
-        @node.type.to_s == "comment"
+        canonical_type == :comment
       end
 
       # Check if this is a datetime
       # @return [Boolean]
       def datetime?
-        %w[offset_date_time local_date_time local_date local_time].include?(@node.type.to_s)
+        canonical_type == :datetime
+      end
+
+      # Check if this is the document root
+      # @return [Boolean]
+      def document?
+        canonical_type == :document
       end
 
       # Get the table name (header) if this is a table
@@ -164,9 +155,10 @@ module Toml
 
         # Find the dotted_key or bare_key child that represents the table name
         @node.each do |child|
-          child_type = child.type.to_s
-          if %w[dotted_key bare_key quoted_key].include?(child_type)
-            return node_text(child)
+          child_canonical = NodeTypeNormalizer.canonical_type(child.type, @backend)
+          if NodeTypeNormalizer.key_type?(child_canonical)
+            # Strip whitespace (Citrus backend includes trailing space in key nodes)
+            return node_text(child)&.strip
           end
         end
         nil
@@ -177,13 +169,14 @@ module Toml
       def key_name
         return unless pair?
 
-        # In TOML tree-sitter, pair has key children (bare_key, quoted_key, or dotted_key)
+        # In TOML, pair has key children (bare_key, quoted_key, or dotted_key)
         @node.each do |child|
-          child_type = child.type.to_s
-          if %w[bare_key quoted_key dotted_key].include?(child_type)
+          child_canonical = NodeTypeNormalizer.canonical_type(child.type, @backend)
+          if NodeTypeNormalizer.key_type?(child_canonical)
             key_text = node_text(child)
-            # Remove surrounding quotes if present
-            return key_text&.gsub(/\A["']|["']\z/, "")
+            # Remove surrounding quotes if present, and strip whitespace
+            # (Citrus backend includes trailing space in key nodes)
+            return key_text&.gsub(/\A["']|["']\z/, "")&.strip
           end
         end
         nil
@@ -195,61 +188,59 @@ module Toml
         return unless pair?
 
         @node.each do |child|
-          child_type = child.type.to_s
-          # Skip keys, get the value
-          next if %w[bare_key quoted_key dotted_key =].include?(child_type)
-
-          return NodeWrapper.new(child, lines: @lines, source: @source)
+          child_canonical = NodeTypeNormalizer.canonical_type(child.type, @backend)
+          # Skip keys, equals sign, whitespace, and unknown (Citrus uses these for delimiters)
+          next if NodeTypeNormalizer.key_type?(child_canonical)
+          next if %i[equals whitespace unknown space].include?(child_canonical)
+
+          return NodeWrapper.new(
+            child,
+            lines: @lines,
+            source: @source,
+            backend: @backend,
+            document_root: @document_root,
+          )
         end
         nil
       end
 
-      # Get key-value pairs from a table or inline_table
+      # Get key-value pairs from a table or inline_table.
+      #
+      # Handles structural differences between backends:
+      # - Tree-sitter: pairs are children of the table node
+      # - Citrus: pairs are siblings at document level (table only contains header)
+      #
+      # For Citrus backend, when no pair children are found, we look for sibling
+      # pairs in the document that belong to this table (pairs after this table's
+      # header but before the next table).
+      #
       # @return [Array<NodeWrapper>]
       def pairs
-        return [] unless table? || inline_table? || document?
+        return [] unless table? || inline_table? || document? || array_of_tables?
 
-        result = []
-        @node.each do |child|
-          next unless child.type.to_s == "pair"
+        # First, try to find pairs as direct children (tree-sitter structure)
+        result = collect_child_pairs
+        return result if result.any?
 
-          result << NodeWrapper.new(child, lines: @lines, source: @source)
-        end
-        result
-      end
+        # For Citrus backend: pairs are siblings, not children
+        # Look for pairs in document that belong to this table
+        return [] if @document_root.nil? || !(table? || array_of_tables?)
 
-      # Check if this is the document root
-      # @return [Boolean]
-      def document?
-        @node.type.to_s == "document"
+        collect_sibling_pairs_for_table
       end
 
       # Get array elements if this is an array
+      #
+      # Handles structural differences between backends:
+      # - Tree-sitter: values are direct children of array node
+      # - Citrus: values are nested inside array_elements container
+      #
       # @return [Array<NodeWrapper>]
       def elements
         return [] unless array?
 
         result = []
-        @node.each do |child|
-          child_type = child.type.to_s
-          # Skip punctuation and comments
-          next if child_type == "comment"
-          next if %w[, \[ \]].include?(child_type)
-
-          result << NodeWrapper.new(child, lines: @lines, source: @source)
-        end
-        result
-      end
-
-      # Get children wrapped as NodeWrappers
-      # @return [Array<NodeWrapper>]
-      def children
-        return [] unless @node.respond_to?(:each)
-
-        result = []
-        @node.each do |child|
-          result << NodeWrapper.new(child, lines: @lines, source: @source)
-        end
+        collect_array_elements(@node, result)
         result
       end
 
@@ -258,8 +249,8 @@ module Toml
       # For other node types, returns empty array (leaf nodes).
       # @return [Array<NodeWrapper>]
       def mergeable_children
-        case type
-        when :table, :inline_table
+        case canonical_type
+        when :table, :inline_table, :array_of_tables
           pairs
         when :array
           elements
@@ -267,10 +258,16 @@ module Toml
           # Return top-level pairs and tables
           result = []
           @node.each do |child|
-            child_type = child.type.to_s
-            next if child_type == "comment"
-
-            result << NodeWrapper.new(child, lines: @lines, source: @source)
+            child_canonical = NodeTypeNormalizer.canonical_type(child.type, @backend)
+            next if child_canonical == :comment
+
+            result << NodeWrapper.new(
+              child,
+              lines: @lines,
+              source: @source,
+              backend: @backend,
+              document_root: @document_root,
+            )
           end
           result
         else
@@ -284,12 +281,6 @@ module Toml
         table? || array_of_tables? || inline_table? || array? || document?
       end
 
-      # Check if this node is a leaf (no mergeable children)
-      # @return [Boolean]
-      def leaf?
-        !container?
-      end
-
       # Get the opening line for a table (the line with [table_name])
       # @return [String, nil]
       def opening_line
@@ -308,109 +299,283 @@ module Toml
         @lines[@end_line - 1]
       end
 
-      # Get the text content for this node by extracting from source using byte positions
+      # Get the content for this node from source lines.
+      #
+      # Handles structural differences between backends:
+      # - Tree-sitter: table nodes include pairs, so start_line..end_line covers everything
+      # - Citrus: table nodes only include header, so we extend to include associated pairs
+      #
       # @return [String]
-      def text
-        node_text(@node)
-      end
+      def content
+        return "" unless @start_line
 
-      # Extract text from a tree-sitter node using byte positions
-      # @param ts_node [TreeHaver::Node] The tree-sitter node
-      # @return [String]
-      def node_text(ts_node)
-        return "" unless ts_node.respond_to?(:start_byte) && ts_node.respond_to?(:end_byte)
+        # For tables with Citrus backend, extend end_line to include pairs
+        effective_end = effective_end_line
+        return "" unless effective_end
 
-        @source[ts_node.start_byte...ts_node.end_byte] || ""
+        (@start_line..effective_end).map { |ln| @lines[ln - 1] }.compact.join("\n")
       end
 
-      # Get the content for this node from source lines
-      # @return [String]
-      def content
-        return "" unless @start_line && @end_line
+      # Get the effective end line for this node, accounting for Citrus backend.
+      # For Citrus tables, this extends to the line before the next table.
+      # @return [Integer, nil]
+      def effective_end_line
+        return @end_line if !(table? || array_of_tables?) || @document_root.nil?
 
-        (@start_line..@end_line).map { |ln| @lines[ln - 1] }.compact.join("\n")
-      end
+        # Check if we have pairs as children (tree-sitter structure)
+        child_pairs = collect_child_pairs
+        return @end_line if child_pairs.any?
 
-      # String representation for debugging
-      # @return [String]
-      def inspect
-        "#<#{self.class.name} type=#{@node.type} lines=#{@start_line}..#{@end_line}>"
+        # Citrus structure: find the last pair that belongs to us
+        sibling_pairs = collect_sibling_pairs_for_table
+        return @end_line if sibling_pairs.empty?
+
+        # Return the end line of the last pair
+        sibling_pairs.map(&:end_line).compact.max || @end_line
       end
 
-      private
+      protected
+
+      # Override wrap_child to use Toml::Merge::NodeWrapper with proper options
+      def wrap_child(child)
+        NodeWrapper.new(
+          child,
+          lines: @lines,
+          source: @source,
+          backend: @backend,
+          document_root: @document_root,
+        )
+      end
 
       def compute_signature(node)
-        node_type = node.type.to_s
+        # Use canonical type for signature generation
+        # Pass @backend to ensure correct type mapping for Citrus vs tree-sitter
+        canonical = NodeTypeNormalizer.canonical_type(node.type, @backend)
 
-        case node_type
-        when "document"
+        case canonical
+        when :document
           # Root document
           [:document]
-        when "table"
+        when :table
           # Tables identified by their header name
           name = table_name
           [:table, name]
-        when "array_of_tables", "table_array_element"
+        when :array_of_tables
           # Array of tables identified by their header name
           name = table_name
           [:array_of_tables, name]
-        when "pair"
+        when :pair
           # Pairs identified by their key name
           key = key_name
           [:pair, key]
-        when "inline_table"
+        when :inline_table
           # Inline tables identified by their keys
           keys = extract_inline_table_keys(node)
           [:inline_table, keys.sort]
-        when "array"
+        when :array
           # Arrays identified by their length
           elements_count = 0
-          node.each do |c|
-            next if %w[comment , \[ \]].include?(c.type.to_s)
-
-            elements_count += 1
-          end
+          node.each { |c| elements_count += 1 unless %i[comment comma bracket_open bracket_close].include?(NodeTypeNormalizer.canonical_type(c.type, @backend)) }
           [:array, elements_count]
-        when "string", "basic_string", "literal_string", "multiline_basic_string", "multiline_literal_string"
+        when :string
           # Strings identified by their content
           [:string, node_text(node)]
-        when "integer"
+        when :integer
           # Integers identified by their value
           [:integer, node_text(node)]
-        when "float"
+        when :float
           # Floats identified by their value
           [:float, node_text(node)]
-        when "boolean"
+        when :boolean
           # Booleans
           [:boolean, node_text(node)]
-        when "offset_date_time", "local_date_time", "local_date", "local_time"
+        when :datetime
           # Datetime values
           [:datetime, node_text(node)]
-        when "comment"
+        when :comment
           # Comments identified by their content
           [:comment, node_text(node)&.strip]
         else
-          # Generic fallback
+          # Generic fallback - use canonical type in signature
           content_preview = node_text(node)&.slice(0, 50)&.strip
-          [node_type.to_sym, content_preview]
+          [canonical, content_preview]
         end
       end
 
+      private
+
       def extract_inline_table_keys(inline_table_node)
         keys = []
-        inline_table_node.each do |child|
-          next unless child.type.to_s == "pair"
-
-          child.each do |pair_child|
-            child_type = pair_child.type.to_s
-            if %w[bare_key quoted_key dotted_key].include?(child_type)
-              key_text = node_text(pair_child)&.gsub(/\A["']|["']\z/, "")
-              keys << key_text if key_text
-              break
+        collect_inline_table_keys_recursive(inline_table_node, keys)
+        keys
+      end
+
+      # Recursively collect keys from inline table, handling both tree-sitter and Citrus structures.
+      #
+      # Tree-sitter inline_table structure:
+      #   inline_table -> pair -> bare_key (direct children)
+      #
+      # Citrus inline_table structure:
+      #   inline_table -> optional -> keyvalue -> keyvalue -> stripped_key -> key -> bare_key
+      #   With repeat and unknown nodes containing additional key-values
+      #
+      def collect_inline_table_keys_recursive(node, keys)
+        node.each do |child|
+          child_canonical = NodeTypeNormalizer.canonical_type(child.type, @backend)
+          child_type_raw = child.type.to_sym
+
+          # For Citrus: recurse into container nodes that hold pairs/keys
+          # For tree-sitter: only recurse into pairs
+          if @backend == :citrus
+            if %i[optional repeat keyvalue unknown].include?(child_type_raw)
+              collect_inline_table_keys_recursive(child, keys)
+              next
+            end
+          elsif child_canonical == :pair
+            # Tree-sitter: pairs contain keys directly
+            child.each do |pair_child|
+              pair_child_canonical = NodeTypeNormalizer.canonical_type(pair_child.type, @backend)
+              if NodeTypeNormalizer.key_type?(pair_child_canonical)
+                key_text = node_text(pair_child)&.gsub(/\A["']|["']\z/, "")&.strip
+                keys << key_text if key_text && !key_text.empty?
+                break
+              end
             end
+            next
+          end
+
+          # Skip whitespace and punctuation
+          next if %i[whitespace space brace_open brace_close comma].include?(child_canonical)
+
+          # Found a key node - extract the key text (Citrus path)
+          if NodeTypeNormalizer.key_type?(child_canonical)
+            key_text = node_text(child)&.gsub(/\A["']|["']\z/, "")&.strip
+            keys << key_text if key_text && !key_text.empty?
           end
         end
-        keys
+      end
+
+      # Collect pairs that are direct children of this node.
+      # This is the standard tree-sitter structure.
+      # @return [Array<NodeWrapper>]
+      def collect_child_pairs
+        result = []
+        @node.each do |child|
+          child_canonical = NodeTypeNormalizer.canonical_type(child.type, @backend)
+          next unless child_canonical == :pair
+
+          result << NodeWrapper.new(
+            child,
+            lines: @lines,
+            source: @source,
+            backend: @backend,
+            document_root: @document_root,
+          )
+        end
+        result
+      end
+
+      # Collect pairs from document siblings that belong to this table.
+      # Used for Citrus backend where pairs are siblings, not children.
+      #
+      # A pair belongs to this table if:
+      # - It appears after this table's header line
+      # - It appears before the next table's header line (or end of document)
+      #
+      # @return [Array<NodeWrapper>]
+      def collect_sibling_pairs_for_table
+        result = []
+        my_start = @start_line
+        return result unless my_start
+
+        # Find the next table's start line (to know where our pairs end)
+        next_table_start = find_next_table_start_line
+
+        # Iterate through document children to find pairs in our range
+        @document_root.each do |sibling|
+          sibling_canonical = NodeTypeNormalizer.canonical_type(sibling.type, @backend)
+          next unless sibling_canonical == :pair
+
+          sibling_start = sibling.respond_to?(:start_point) ? sibling.start_point.row + 1 : nil
+          next unless sibling_start
+
+          # Pair must be after our header
+          next if sibling_start <= my_start
+
+          # Pair must be before the next table (if there is one)
+          next if next_table_start && sibling_start >= next_table_start
+
+          result << NodeWrapper.new(
+            sibling,
+            lines: @lines,
+            source: @source,
+            backend: @backend,
+            document_root: @document_root,
+          )
+        end
+
+        result
+      end
+
+      # Find the start line of the next table in the document.
+      # Returns nil if this is the last table.
+      # @return [Integer, nil]
+      def find_next_table_start_line
+        return unless @document_root
+
+        my_start = @start_line
+        next_table_start = nil
+
+        @document_root.each do |sibling|
+          sibling_canonical = NodeTypeNormalizer.canonical_type(sibling.type, @backend)
+          next unless NodeTypeNormalizer.table_type?(sibling_canonical)
+
+          sibling_start = sibling.respond_to?(:start_point) ? sibling.start_point.row + 1 : nil
+          next unless sibling_start
+          next if sibling_start <= my_start
+
+          # Found a table after us - track the closest one
+          if next_table_start.nil? || sibling_start < next_table_start
+            next_table_start = sibling_start
+          end
+        end
+
+        next_table_start
+      end
+
+      # Recursively collect array elements, handling Citrus's nested structure.
+      #
+      # Citrus array structure:
+      #   array -> array_elements -> array_elements -> decimal_integer + repeat
+      #   repeat -> indent -> decimal_integer (for each subsequent element)
+      #
+      # @param node [Object] Node to collect elements from
+      # @param result [Array<NodeWrapper>] Array to append elements to
+      def collect_array_elements(node, result)
+        node.each do |child|
+          child_canonical = NodeTypeNormalizer.canonical_type(child.type, @backend)
+          child_type_raw = child.type.to_sym
+
+          # For Citrus: recurse into container nodes that hold values
+          if %i[array_elements repeat indent].include?(child_type_raw)
+            collect_array_elements(child, result)
+            next
+          end
+
+          # Skip punctuation, comments, whitespace, and structural nodes
+          next if child_canonical == :comment
+          next if %i[comma bracket_open bracket_close].include?(child_canonical)
+          next if %i[whitespace unknown space array_comments sign].include?(child_canonical)
+
+          # This is an actual value element (integer, string, boolean, etc.)
+          result << NodeWrapper.new(
+            child,
+            lines: @lines,
+            source: @source,
+            backend: @backend,
+            document_root: @document_root,
+          )
+        end
       end
     end
   end