canon 0.3.61 → 0.3.63

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b5b90b7fc1d45d8f8e58e804f3f67dae934cc225639f3196c64f43cdd84ae005
-  data.tar.gz: c6615312bb2ac6eba00700c60b7dfeeb18277b8677532f98f91e4ad24a29c562
+  metadata.gz: 0a25343915041867345d470570eb9a84d2266e4b95b89b730bee32a0a99b112f
+  data.tar.gz: 501f8c0e6c7430611a0c68c3b31b2d30ce63ec411bd6426e854fdb9c57a4f6ac
 SHA512:
-  metadata.gz: 75e2773c9597d616988157bdd40f4df3478dfd5695c1b9c7b9fc3709a6b043e22e98d3a1d9f2221ad06f7d4bb249331b1356606dce4acf10ce4bdfd8c254d209
-  data.tar.gz: 2877cc2367ac8da5ef68ea9b2ba2cc94883754a47aaf7dba51aef1050d67b9f3d95027238a539e119c92704fa696bdd8de8412bf178098a00e03061fbbb48888
+  metadata.gz: df2fb54642dffbc16670860f406bfce3e76d4665772d5d0394dd65762157ce821ab8d315c8a761abfd3d6ac9a72467039549fccaedfc5ea0ac7596852a898e28
+  data.tar.gz: 31781f1ef8b498980a1ca4036ebf9337f6716744f9f6d6e11519aa5ca4d0356d18c6679bc9091a10280b466abab0471e199c9db0d5c4138a27e992dff2af5623

data/lib/canon/diff/formatting_detector.rb

@@ -17,8 +17,60 @@ module Canon
         # If only one is blank, it's not just formatting
         return false if blank?(line1) || blank?(line2)
 
-        # Compare normalized versions
-        normalize_for_comparison(line1) == normalize_for_comparison(line2)
+        return true if line1 == line2
+
+        # Identical prefix/suffix bytes normalize identically — compare
+        # only the differing core, widened to tag boundaries so no tag,
+        # entity, or whitespace run spans a cut (the normalization is
+        # then compositional across the cut points).
+        core1, core2 = differing_core(line1, line2)
+        return false if core1.nil?
+
+        normalize_for_comparison(core1) == normalize_for_comparison(core2)
+      end
+
+      # The differing core of two lines: the region between the common
+      # prefix and common suffix, widened outward to just after a ">" so
+      # the cuts never split a tag, an entity reference, or a whitespace
+      # run. Returns nil when the bytes are identical (no core).
+      #
+      # @param line1 [String]
+      # @param line2 [String]
+      # @return [Array(String, String), nil]
+      def self.differing_core(line1, line2)
+        return nil if line1 == line2
+
+        size1 = line1.bytesize
+        size2 = line2.bytesize
+        limit = [size1, size2].min
+        lo = 0
+        lo += 1 while lo < limit && line1.getbyte(lo) == line2.getbyte(lo)
+
+        suffix_max = limit - lo
+        s = 0
+        s += 1 while s < suffix_max &&
+            line1.getbyte(size1 - 1 - s) == line2.getbyte(size2 - 1 - s)
+
+        # Snap the cuts to tag boundaries (the shared regions are
+        # identical, so the cuts apply to both lines alike): the left
+        # cut moves to the start of the enclosing tag so attribute
+        # normalization always sees whole tags; the right cut moves
+        # past the closing ">".
+        tag_lo = line1.rindex("<", lo)
+        lo = tag_lo if tag_lo
+
+        hi1 = size1 - s
+        hi2 = size2 - s
+        tag_hi = line1.index(">", hi1)
+        if tag_hi
+          hi1 = tag_hi + 1
+          hi2 = hi1 + (size2 - size1) # same offset within the shared tail
+        end
+
+        # Degenerate widening (empty core) — compare the full lines.
+        return [line1, line2] if lo > hi1 || hi2 < lo
+
+        [line1[lo...hi1], line2[lo...hi2]]
       end
 
       # Aggressive normalization for formatting comparison.
@@ -107,8 +159,14 @@ module Canon
       # case-insensitive (e.g., "UTF-8" equals "utf-8").
       # The standalone declaration in XML 1.1 is also case-insensitive.
       CASE_INSENSITIVE_ATTRS = %w[encoding standalone].freeze
-      QUOTE_CHARS = ["\"", "'"].freeze
-      SKIP_CHARS = [" ", "="].freeze
+      # Byte-level scan sets — the tokenizer reads via getbyte, whose
+      # Integer results allocate nothing (String#[] mints a 1-char
+      # string per character scanned).
+      NAME_END_BYTES = [32, 47, 62].freeze # space, /, >
+      SKIP_BYTES = [32, 61].freeze         # space, =
+      QUOTE_BYTES = [34, 39].freeze        # ", '
+      SPACE_BYTE = 32
+      EMPTY_CONTENT_RE = /\A[ \t\r\n\f\v]*\z/
 
       # Normalize attribute order within XML tags so that
       # <elem b="2" a="1"> compares equal to <elem a="1" b="2">.
@@ -121,19 +179,23 @@ module Canon
         i = 0
 
         while i < text.length
-          if text[i] == "<"
-            # Handle processing instruction <?...?>, comment <!--...-->,
-            # and regular tags
-            new_i, tag_output = process_tag(text, i)
-            if new_i
-              result << tag_output
-              i = new_i
-              next
-            end
+          lt = text.index("<", i)
+          if lt.nil?
+            result << text[i..]
+            break
+          end
+          result << text[i...lt] if lt > i
+
+          # Handle processing instruction <?...?>, comment <!--...-->,
+          # and regular tags
+          new_i, tag_output = process_tag(text, lt)
+          if new_i
+            result << tag_output
+            i = new_i
+          else
+            result << "<"
+            i = lt + 1
           end
-
-          result << text[i]
-          i += 1
         end
 
         result
@@ -178,57 +240,59 @@ module Canon
       # @param tag_content [String] Content between < and >
       # @return [Hash, nil] { name: String, attrs: Array<{name:, value:}> }
       def self.tokenize_tag_content(tag_content)
-        return nil if tag_content.strip.empty?
+        return nil if tag_content.match?(EMPTY_CONTENT_RE)
 
         i = 0
+        length = tag_content.length
         # Find tag name (first non-whitespace word)
-        i += 1 while i < tag_content.length && tag_content[i] == " "
-        return nil if i >= tag_content.length
+        i += 1 while i < length && tag_content.getbyte(i) == SPACE_BYTE
+        return nil if i >= length
 
         name_start = i
-        i += 1 while i < tag_content.length && tag_content[i] != " " &&
-            tag_content[i] != "/" && tag_content[i] != ">"
+        i += 1 while i < length &&
+            !NAME_END_BYTES.include?(tag_content.getbyte(i))
         tag_name = tag_content[name_start...i]
 
         # Skip whitespace
-        i += 1 while i < tag_content.length && tag_content[i] == " "
+        i += 1 while i < length && tag_content.getbyte(i) == SPACE_BYTE
 
         # Parse attributes
         attrs = []
-        while i < tag_content.length
+        while i < length
           # Skip whitespace
-          i += 1 while i < tag_content.length && tag_content[i] == " "
-          break if i >= tag_content.length
+          i += 1 while i < length && tag_content.getbyte(i) == SPACE_BYTE
+          break if i >= length
 
           # Read attribute name
           attr_start = i
-          i += 1 while i < tag_content.length && tag_content[i] != "=" &&
-              tag_content[i] != " " && tag_content[i] != "/" &&
-              tag_content[i] != ">"
-          break if i >= tag_content.length || i == attr_start
+          i += 1 while i < length &&
+              !NAME_END_BYTES.include?(tag_content.getbyte(i)) &&
+              tag_content.getbyte(i) != 61
+          break if i >= length || i == attr_start
 
           attr_name = tag_content[attr_start...i]
 
           # Skip whitespace and =
-          i += 1 while i < tag_content.length &&
-              SKIP_CHARS.include?(tag_content[i])
-          break if i >= tag_content.length
+          i += 1 while i < length &&
+              SKIP_BYTES.include?(tag_content.getbyte(i))
+          break if i >= length
 
           # Read quoted value
-          quote = tag_content[i]
-          break unless QUOTE_CHARS.include?(quote)
+          quote = tag_content.getbyte(i)
+          break unless QUOTE_BYTES.include?(quote)
 
           i += 1
           value_start = i
-          while i < tag_content.length && tag_content[i] != quote
+          while i < length && tag_content.getbyte(i) != quote
             i += 1
           end
-          break if i >= tag_content.length
+          break if i >= length
 
           attr_value = tag_content[value_start...i]
           i += 1 # skip closing quote
 
-          attrs << { name: attr_name, value: "#{quote}#{attr_value}#{quote}" }
+          quote_char = quote.chr
+          attrs << { name: attr_name, value: "#{quote_char}#{attr_value}#{quote_char}" }
         end
 
         { name: tag_name, attrs: attrs }
@@ -241,9 +305,9 @@ module Canon
       # @param i [Integer] Position of '<'
       # @return [Array(Integer, String), nil] [new_position, tag_string] or nil
       def self.process_tag(text, pos)
-        if text[pos + 1] == "?"
+        if text.getbyte(pos + 1) == 63 # ?
           process_processing_instruction(text, pos)
-        elsif text[pos + 1] == "!" && text[(pos + 2)...(pos + 4)] == "--"
+        elsif text.getbyte(pos + 1) == 33 && text[(pos + 2)...(pos + 4)] == "--" # !
           process_comment(text, pos)
         else
           process_regular_tag(text, pos)

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

@@ -642,6 +642,23 @@ module Canon
         #
         # @param token [String] The token to apply visualization to
         # @param color [Symbol, nil] Optional color to apply
+        # Whole-string gsub through the map — the previous
+        # chars.map.fetch.join minted two arrays and one 1-char string
+        # per character of every displayed line.
+        def visualize(token)
+          return token if @visualization_map.empty?
+
+          token.gsub(visualization_union, @visualization_map)
+        end
+
+        # Longer keys first so "\r\n" wins over "\r"/"\n" at the
+        # same position.
+        def visualization_union
+          @visualization_union ||= Regexp.union(
+            @visualization_map.keys.sort_by(&:length).reverse,
+          )
+        end
+
         # @return [String] Visualized and optionally colored token
         def apply_visualization(token, color = nil)
           return "" if token.nil?
@@ -649,9 +666,7 @@ module Canon
           visual = if @character_visualization == :content_only
                      visualize_content_only(token.to_s)
                    else
-                     token.to_s.chars.map do |char|
-                       @visualization_map.fetch(char, char)
-                     end.join
+                     visualize(token.to_s)
                    end
 
           if color && @use_color

data/lib/canon/version.rb

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

metadata

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