canon 0.3.43 → 0.3.45

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 88bb496bdbab5cc434e73d3f353563e110bbaf0b73a76f009886e45743206984
-  data.tar.gz: c00284c8cc531ed825633e8e2250a1dbead21ec4db083529a6bef5d3b909bd4b
+  metadata.gz: a17cd55bc56c7287d027191b11cd33a6bc0999b29abce17bb8c368758379e4ad
+  data.tar.gz: 7b7c89255ad4134219b512265b6b26c08a1352742dfc1500a821a830fa3cd2d3
 SHA512:
-  metadata.gz: 7e32bb5f265281f3ba69a7b9c130025d84f27578084a8a90267edaefc7e5cc6cedd8b2aa72db0a930d38def70ac07f826fc80e767cda72089d3ebedbc88219f4
-  data.tar.gz: 82a1b117a2f121dbd436962937b1aec7de7ef691b8d15f51fbf69155d6ff9fe09af5ed5f69efdbfa4724af65dbd3858525a56ac22ebb6d603c91ad9b032ab590
+  metadata.gz: d4673a7e48e7fb4aa901ece0c6fc3c097e3c046af4aee63b959b218d8809a32ac9e8f4ea3db990ff969f521d9842e826e03f4815da8610fba7138070cc420f8e
+  data.tar.gz: f5771189aed0ef86eb98b32b9bd94261221688aece84f6f7b44861c66afcde65d80b3b0a2cb599bb96c18aaa575da4ff86d1bb385b48ff7a3ff34c858342a632

data/lib/canon/diff/diff_node_enricher.rb

@@ -927,7 +927,7 @@ module Canon
       # @return [Integer] the last line number
       def find_end_line(start_line, line_map, content)
         newline_count = content.count("\n")
-        [start_line + newline_count, line_map.length - 1].min
+        [start_line + newline_count, line_map.line_count - 1].min
       end
 
       # Find the occurrence of a value at a specific element index.
@@ -1016,7 +1016,7 @@ module Canon
         # so the prefix scan counts exactly the preceding siblings —
         # no "inside the element" correction (count_elements_before_
         # position subtracts one for text-node offsets).
-        opener = /<#{element_name}[>\s]/
+        opener = opener_for(element_name)
         occurrences = SourceLocator.locate_all(value, text, line_map)
         occurrences.each do |occ|
           count = count_elements_before_position_open(text,
@@ -1093,7 +1093,7 @@ module Canon
                                                       line_map)
         return nil unless line_idx
 
-        col = search_start - line_map[line_idx][:start_offset]
+        col = search_start - line_map.start_at(line_idx)
         { char_offset: search_start, line_number: line_idx, col: col }
       end
 
@@ -1265,7 +1265,7 @@ range_start, range_end)
                                                               line_map)
                 return nil unless line_idx
 
-                col = value_pos - line_map[line_idx][:start_offset]
+                col = value_pos - line_map.start_at(line_idx)
                 return { char_offset: value_pos, line_number: line_idx,
                          col: col }
               end
@@ -1280,7 +1280,7 @@ range_start, range_end)
                                                         line_map)
           return nil unless line_idx
 
-          col = value_pos - line_map[line_idx][:start_offset]
+          col = value_pos - line_map.start_at(line_idx)
           return { char_offset: value_pos, line_number: line_idx, col: col }
         end
 
@@ -1332,7 +1332,7 @@ range_start, range_end)
                                                             line_map)
               return nil unless line_idx
 
-              col = value_pos - line_map[line_idx][:start_offset]
+              col = value_pos - line_map.start_at(line_idx)
               return { char_offset: value_pos, line_number: line_idx, col: col }
             end
           end
@@ -1386,7 +1386,7 @@ range_start, range_end)
                                                             line_map)
               return nil unless line_idx
 
-              col = anchor_pos - line_map[line_idx][:start_offset]
+              col = anchor_pos - line_map.start_at(line_idx)
               return { char_offset: anchor_pos, line_number: line_idx,
                        col: col }
             else
@@ -1395,7 +1395,7 @@ range_start, range_end)
                                                             line_map)
               return nil unless line_idx
 
-              col = tag_end_pos - line_map[line_idx][:start_offset]
+              col = tag_end_pos - line_map.start_at(line_idx)
               return { char_offset: tag_end_pos, line_number: line_idx,
                        col: col }
             end
@@ -1447,6 +1447,15 @@ range_start, range_end)
       # @param char_offset [Integer] character offset to check before
       # @param element_name [String] name of element to count
       # @return [Integer] element index (0-based) of the element containing the position
+      # Opener regexes memoized per element name — compiling
+      # /<name[>\s]/ per call was an allocation per occurrence check.
+      OPENER_CACHE = {}.compare_by_identity
+      private_constant :OPENER_CACHE
+
+      def opener_for(element_name)
+        OPENER_CACHE[element_name] ||= /<#{element_name}[>\s]/
+      end
+
       # Occurrence count with offsets AT the element's own opening
       # tag (no inside-the-element correction — see
       # locate_element_at_index).

data/lib/canon/diff/source_locator.rb

@@ -15,23 +15,51 @@ module Canon
     #   SourceLocator.locate("line2", "line1\nline2\nline3", line_map)
     #   # => { char_offset: 6, line_number: 1, col: 0 }
     class SourceLocator
+      # Line offset map: two flat Integer arrays (starts, ends) — a
+      # hash-per-line was one allocation per document line on every
+      # enrichment, the presentation stage's quiet constant.
+      class LineMap
+        attr_reader :starts, :ends
+
+        def initialize(starts, ends)
+          @starts = starts
+          @ends = ends
+        end
+
+        def empty?
+          @starts.empty?
+        end
+
+        def line_count
+          @starts.length
+        end
+
+        def start_at(index)
+          @starts[index]
+        end
+
+        def end_at(index)
+          @ends[index]
+        end
+      end
+
       # Build a line offset map from source text.
-      # Each entry records the start and end character offset of a line.
       #
       # @param text [String] the full source text
-      # @return [Array<Hash>] array of { start_offset:, end_offset: } hashes,
-      #   one per line (0-indexed)
+      # @return [LineMap] flat offset arrays, one entry per line
+      #   (0-indexed)
       def self.build_line_map(text)
-        return [] if text.nil? || text.empty?
+        return LineMap.new([], []) if text.nil? || text.empty?
 
-        map = []
+        starts = []
         offset = 0
         text.each_line do |line|
-          line_end = offset + line.length
-          map << { start_offset: offset, end_offset: line_end }
-          offset = line_end
+          starts << offset
+          offset += line.length
         end
-        map
+        ends = starts[1..] || []
+        ends << text.length
+        LineMap.new(starts, ends)
       end
 
       # Locate a substring within source text and return its position.
@@ -55,7 +83,7 @@ module Canon
         line_idx = find_line_for_offset(char_offset, line_map)
         return nil if line_idx.nil?
 
-        col = char_offset - line_map[line_idx][:start_offset]
+        col = char_offset - line_map.start_at(line_idx)
 
         { char_offset: char_offset, line_number: line_idx, col: col }
       end
@@ -77,7 +105,7 @@ module Canon
           line_idx = find_line_for_offset(pos, line_map)
           break if line_idx.nil?
 
-          col = pos - line_map[line_idx][:start_offset]
+          col = pos - line_map.start_at(line_idx)
           results << { char_offset: pos, line_number: line_idx, col: col }
           offset = pos + 1
         end
@@ -92,8 +120,8 @@ module Canon
         # @param line_map [Array<Hash>] the line offset map
         # @return [Integer, nil] the 0-based line index, or nil
         def find_line_for_offset(char_offset, line_map)
-          line_map.bsearch_index do |entry|
-            entry[:end_offset] > char_offset
+          line_map.ends.bsearch_index do |end_offset|
+            end_offset > char_offset
           end
         end
       end

data/lib/canon/diff_formatter/by_line/xml_formatter.rb

@@ -87,25 +87,91 @@ module Canon
           end
           return if unlocated.empty?
 
-          lines = []
+          # Place each unlocated node's context after the report
+          # context containing its nearest preceding LOCATED node
+          # (@differences is comparator-walk order = document order),
+          # so the change reads in position instead of trailing.
           unlocated.each do |dn|
-            fmt = dn.formatting?
-            dn.serialized_before&.split("\n")&.each do |line|
+            context = Canon::Diff::DiffContext.new(
+              lines: unlocated_lines(dn),
+            )
+            anchor_index = context_index_after(report, preceding_located(dn))
+            report.contexts.insert(anchor_index, context)
+          end
+        end
+
+        # Mini-diff of one unlocated node's serialized sides: shared
+        # lines render as :unchanged context instead of remove-all +
+        # add-all. Blank line numbers throughout — no located position.
+        def unlocated_lines(diff_node)
+          before = diff_node.serialized_before&.split("\n") || []
+          after = diff_node.serialized_after&.split("\n") || []
+          fmt = diff_node.formatting?
+          lines = []
+          require "diff/lcs" unless defined?(::Diff::LCS)
+
+          ::Diff::LCS.sdiff(before, after).each do |change|
+            case change.action
+            when "="
               lines << Canon::Diff::DiffLine.new(
-                line_number: nil, new_position: nil, content: line,
-                type: :removed, diff_node: dn, formatting: fmt
+                line_number: nil, new_position: nil,
+                content: change.old_element, type: :unchanged,
+                diff_node: diff_node
               )
-            end
-            next unless dn.serialized_after
-
-            dn.serialized_after.split("\n").each do |line|
+            when "-"
+              lines << Canon::Diff::DiffLine.new(
+                line_number: nil, new_position: nil,
+                content: change.old_element, type: :removed,
+                diff_node: diff_node, formatting: fmt
+              )
+            when "+"
               lines << Canon::Diff::DiffLine.new(
-                line_number: nil, new_position: nil, content: line,
-                type: :added, diff_node: dn, formatting: fmt
+                line_number: nil, new_position: nil,
+                content: change.new_element, type: :added,
+                diff_node: diff_node, formatting: fmt
               )
+            when "!"
+              lines << Canon::Diff::DiffLine.new(
+                line_number: nil, new_position: nil,
+                content: change.old_element, type: :removed,
+                diff_node: diff_node, formatting: fmt
+              )
+              lines << Canon::Diff::DiffLine.new(
+                line_number: nil, new_position: nil,
+                content: change.new_element, type: :added,
+                diff_node: diff_node, formatting: fmt
+              )
+            end
+          end
+          lines
+        end
+
+        # The nearest preceding node (in @differences walk order)
+        # that the enricher DID locate.
+        def preceding_located(diff_node)
+          index = @differences.index(diff_node)
+          return nil unless index
+
+          (index - 1).downto(0) do |i|
+            dn = @differences[i]
+            return dn if dn.char_ranges && !dn.char_ranges.empty?
+          end
+          nil
+        end
+
+        # Index into report.contexts for inserting an unlocated
+        # context: after the context holding the anchor node's lines,
+        # or at the front when the anchor is nil (nothing precedes).
+        def context_index_after(report, anchor_node)
+          return 0 if anchor_node.nil?
+
+          report.contexts.each_with_index do |context, idx|
+            has_anchor = context.lines.any? do |dl|
+              dl.diff_node&.equal?(anchor_node)
             end
+            return idx + 1 if has_anchor
           end
-          report.contexts << Canon::Diff::DiffContext.new(lines: lines)
+          report.contexts.length
         end
 
         # Format a DiffReport for display

data/lib/canon/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Canon
-  VERSION = "0.3.43"
+  VERSION = "0.3.45"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: canon
 version: !ruby/object:Gem::Version
-  version: 0.3.43
+  version: 0.3.45
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-09-15 00:00:00.000000000 Z
+date: 2026-09-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: diff-lcs