canon 0.1.8 → 0.1.10

data/scripts/test_readme_examples.rb

@@ -1,131 +0,0 @@
-#!/usr/bin/env ruby
-# frozen_string_literal: true
-
-require_relative "../lib/canon"
-require_relative "../lib/canon/comparison"
-require_relative "../lib/canon/pretty_printer/xml"
-require_relative "../lib/canon/xml/c14n"
-require_relative "../lib/canon/config"
-
-puts "Testing corrected README.adoc examples..."
-puts "=" * 60
-
-# Test 1: Canon.format (default pretty-print)
-puts "\n1. Testing Canon.format with XML (default)..."
-begin
-  result = Canon.format("<root><b>2</b><a>1</a></root>", :xml)
-  if result.include?("<?xml") && result.include?("<root>")
-    puts "✓ Canon.format works (returns pretty-printed XML)"
-  else
-    puts "✗ Canon.format unexpected output"
-  end
-rescue StandardError => e
-  puts "✗ Canon.format failed: #{e.message}"
-end
-
-# Test 2: Canonical form (compact)
-puts "\n2. Testing Canon::Xml::C14n.canonicalize..."
-begin
-  result = Canon::Xml::C14n.canonicalize("<root><b>2</b><a>1</a></root>",
-                                         with_comments: false)
-  expected = "<root><b>2</b><a>1</a></root>"
-  if result == expected
-    puts "✓ Canon::Xml::C14n.canonicalize works"
-    puts "  Result: #{result}"
-  else
-    puts "✗ Unexpected result: #{result}"
-  end
-rescue StandardError => e
-  puts "✗ Canon::Xml::C14n.canonicalize failed: #{e.message}"
-end
-
-# Test 3: Pretty printer with variable
-puts "\n3. Testing Canon::PrettyPrinter::Xml with defined variable..."
-begin
-  xml_input = "<root><b>2</b><a>1</a></root>"
-  result = Canon::PrettyPrinter::Xml.new(indent: 2).format(xml_input)
-  if result.include?("<?xml") && result.include?("<root>")
-    puts "✓ Canon::PrettyPrinter::Xml works with defined variable"
-  else
-    puts "✗ Unexpected output"
-  end
-rescue StandardError => e
-  puts "✗ Canon::PrettyPrinter::Xml failed: #{e.message}"
-end
-
-# Test 4: Basic comparison
-puts "\n4. Testing Canon::Comparison.equivalent?..."
-begin
-  xml1 = "<root><a>1</a><b>2</b></root>"
-  xml2 = "<root>  <b>2</b>  <a>1</a>  </root>"
-  result = Canon::Comparison.equivalent?(xml1, xml2)
-  puts "✓ Canon::Comparison.equivalent? works"
-  puts "  Result: #{result}"
-rescue StandardError => e
-  puts "✗ Canon::Comparison.equivalent? failed: #{e.message}"
-end
-
-# Test 5: Semantic tree diff
-puts "\n5. Testing semantic tree diff with operations..."
-begin
-  xml1 = "<root><a>1</a><b>2</b></root>"
-  xml2 = "<root>  <b>2</b>  <a>1</a>  </root>"
-  result = Canon::Comparison.equivalent?(xml1, xml2,
-                                         verbose: true,
-                                         diff_algorithm: :semantic)
-  if result.respond_to?(:operations)
-    puts "✓ Semantic tree diff works"
-    puts "  Result class: #{result.class}"
-    puts "  Operations available: #{result.operations.class}"
-  else
-    puts "✗ Result doesn't have operations method"
-  end
-rescue StandardError => e
-  puts "✗ Semantic tree diff failed: #{e.message}"
-end
-
-# Test 6: RSpec configuration (using Canon::Config)
-puts "\n6. Testing Canon::Config.configure..."
-begin
-  Canon::Config.configure do |config|
-    config.xml.match.profile = :spec_friendly
-    config.xml.diff.use_color = true
-  end
-  profile = Canon::Config.instance.xml.match.profile
-  use_color = Canon::Config.instance.xml.diff.use_color
-  if profile == :spec_friendly && use_color == true
-    puts "✓ Canon::Config.configure works correctly"
-    puts "  Profile: #{profile}"
-    puts "  Use color: #{use_color}"
-  else
-    puts "✗ Configuration values not set correctly"
-  end
-rescue StandardError => e
-  puts "✗ Canon::Config.configure failed: #{e.message}"
-end
-
-# Test 7: Comparison with custom options
-puts "\n7. Testing Canon::Comparison with match options..."
-begin
-  doc1 = "<root><a> text </a></root>"
-  doc2 = "<root><a>text</a></root>"
-  result = Canon::Comparison.equivalent?(doc1, doc2,
-                                         match: {
-                                           text_content: :normalize,
-                                           structural_whitespace: :ignore,
-                                           comments: :ignore,
-                                         },
-                                         verbose: true)
-  if result.respond_to?(:equivalent?)
-    puts "✓ Canon::Comparison with match options works"
-    puts "  Result equivalent: #{result.equivalent?}"
-  else
-    puts "✗ Result doesn't have expected methods"
-  end
-rescue StandardError => e
-  puts "✗ Canon::Comparison with match options failed: #{e.message}"
-end
-
-puts "\n#{'=' * 60}"
-puts "All tests completed successfully! ✓"
-puts "=" * 60

data/scripts/test_semantic_tree_diff.rb

@@ -1,99 +0,0 @@
-#!/usr/bin/env ruby
-# frozen_string_literal: true
-
-require "bundler/setup"
-require "canon"
-require "canon/diff_formatter"
-
-# Test XML with differences
-xml1 = <<~XML
-  <root>
-    <section id="1">
-      <title>First Section</title>
-      <paragraph>Original text</paragraph>
-    </section>
-    <section id="2">
-      <title>Second Section</title>
-    </section>
-  </root>
-XML
-
-xml2 = <<~XML
-  <root>
-    <section id="1">
-      <title>First Section Modified</title>
-      <paragraph>Changed text</paragraph>
-    </section>
-    <section id="3">
-      <title>Third Section</title>
-    </section>
-  </root>
-XML
-
-puts "=" * 80
-puts "Testing Semantic Tree Diff vs DOM Diff"
-puts "=" * 80
-puts
-
-# Test with show_compare enabled
-puts "Running with show_compare=true (verbose mode)..."
-puts "-" * 80
-
-result = Canon::Comparison.equivalent?(
-  xml1,
-  xml2,
-  verbose: true,
-  show_compare: true,
-)
-
-if result.is_a?(Canon::Comparison::CombinedComparisonResult)
-  puts "\n✓ Got CombinedComparisonResult"
-  puts "  Decision Algorithm: #{result.decision_algorithm}"
-  puts "  Equivalent? #{result.equivalent?}"
-  puts
-
-  puts "DOM Diff Algorithm:"
-  puts "-" * 40
-  dom_result = result.dom_result
-  if dom_result.respond_to?(:differences)
-    puts "  Number of differences: #{dom_result.differences.length}"
-    dom_result.differences.first(3).each_with_index do |diff, i|
-      puts "  #{i + 1}. #{diff.inspect[0..200]}"
-    end
-  else
-    puts "  Result: #{dom_result.inspect[0..200]}"
-  end
-  puts
-
-  puts "Tree Diff Algorithm:"
-  puts "-" * 40
-  tree_result = result.tree_result
-  if tree_result.respond_to?(:differences)
-    puts "  Number of differences: #{tree_result.differences.length}"
-    tree_result.differences.first(3).each_with_index do |diff, i|
-      puts "  #{i + 1}. #{diff.inspect[0..200]}"
-    end
-  else
-    puts "  Result: #{tree_result.inspect[0..200]}"
-  end
-  puts
-
-  # Test formatting
-  puts "Formatted Output:"
-  puts "-" * 40
-  begin
-    formatted = Canon::DiffFormatter.format(result, mode: :by_line)
-    puts formatted[0..500]
-  rescue StandardError => e
-    puts "  Error formatting: #{e.message}"
-    puts "  #{e.backtrace.first(3).join("\n  ")}"
-  end
-else
-  puts "✗ Did not get CombinedComparisonResult, got: #{result.class}"
-  puts "  Result: #{result.inspect[0..200]}"
-end
-
-puts
-puts "=" * 80
-puts "Test Complete"
-puts "=" * 80

data/scripts/test_semantic_ux_improvements.rb

@@ -1,135 +0,0 @@
-#!/usr/bin/env ruby
-# frozen_string_literal: true
-
-# Test semantic tree diff UX improvements
-# Verifies that:
-# 1. XPath includes position numbers
-# 2. Element content previews are shown
-# 3. Specific error categories match DOM clarity
-
-require_relative "../lib/canon"
-
-# Test case: HTML with multiple paragraphs to verify position numbers
-html1 = <<~HTML
-  <html>
-    <body>
-      <div>
-        <p>First paragraph</p>
-        <p>Second paragraph</p>
-        <p>Third paragraph</p>
-      </div>
-    </body>
-  </html>
-HTML
-
-html2 = <<~HTML
-  <html>
-    <body>
-      <div>
-        <p>First paragraph</p>
-        <p id="modified">Second paragraph with changes</p>
-        <p>Third paragraph</p>
-        <p>Fourth paragraph added</p>
-      </div>
-    </body>
-  </html>
-HTML
-
-puts "=" * 80
-puts "Testing Semantic Tree Diff UX Improvements"
-puts "=" * 80
-puts
-
-# Test with semantic algorithm
-result = Canon::Comparison.equivalent?(
-  html1,
-  html2,
-  diff_algorithm: :semantic,
-  format: :html,
-  verbose: true,
-)
-
-puts "Equivalent: #{result.equivalent?}"
-puts
-puts "Differences found: #{result.differences.length}"
-puts
-
-# Check each difference for UX improvements
-result.differences.each_with_index do |diff, i|
-  puts "─" * 80
-  puts "Difference ##{i + 1}:"
-  puts "  Dimension: #{diff.dimension}"
-  puts "  Reason: #{diff.reason}"
-
-  # Check XPath has position numbers
-  node = diff.node1 || diff.node2
-  if node
-    xpath = if node.respond_to?(:path)
-              node.path
-            else
-              "(no xpath)"
-            end
-    puts "  XPath: #{xpath}"
-
-    # Verify position numbers are included
-    if xpath.include?("[") && xpath.include?("]")
-      puts "  ✓ XPath includes position numbers"
-    else
-      puts "  ✗ WARNING: XPath missing position numbers"
-    end
-  end
-
-  # Check if reason is specific and actionable
-  if diff.reason
-    if diff.reason.include?("Missing") || diff.reason.include?("Extra") ||
-        diff.reason.include?("changed:") || diff.reason.include?("→")
-      puts "  ✓ Reason is specific and actionable"
-    else
-      puts "  ⚠ Reason could be more specific: #{diff.reason}"
-    end
-  end
-
-  puts
-end
-
-puts "=" * 80
-puts "Formatted output:"
-puts "=" * 80
-puts result
-
-# Test attribute differences
-puts "\n\n"
-puts "=" * 80
-puts "Testing Attribute Difference Details"
-puts "=" * 80
-
-attr_html1 = '<div class="old" id="test" data-value="1">Content</div>'
-attr_html2 = '<div class="new" id="test" data-value="2" data-extra="added">Content</div>'
-
-attr_result = Canon::Comparison.equivalent?(
-  attr_html1,
-  attr_html2,
-  diff_algorithm: :semantic,
-  format: :html,
-  verbose: true,
-)
-
-puts "Differences:"
-attr_result.differences.each do |diff|
-  puts "  Dimension: #{diff.dimension}"
-  puts "  Reason: #{diff.reason}"
-
-  # Check for specific attribute details
-  if diff.reason.include?("Missing:") || diff.reason.include?("Extra:") || diff.reason.include?("Changed:")
-    puts "  ✓ Shows specific attribute changes"
-  end
-  puts
-end
-
-puts "Formatted output:"
-puts attr_result
-
-puts "\n"
-puts "=" * 80
-puts "Test complete!"
-puts "=" * 80

data/scripts/test_single_false_positive.rb

@@ -1,119 +0,0 @@
-#!/usr/bin/env ruby
-# frozen_string_literal: true
-
-# Test a single false positive case to understand the pattern
-# Usage: ruby scripts/test_single_false_positive.rb
-
-require "bundler/setup"
-require "canon"
-
-# Based on MIXED_CONTENT_FIX_RESULTS.md, one false positive is in sourcecode_spec.rb:124
-# Let's test a simple sourcecode case with whitespace
-
-# This represents a typical sourcecode/pre element case
-expected = <<~HTML
-  <div class="example">
-    <pre class="sourcecode" id="X">
-      Line 1
-      Line 2
-    </pre>
-  </div>
-HTML
-
-actual = <<~HTML
-    <div class="example">
-      <pre class="sourcecode" id="X">Line 1
-  Line 2</pre>
-    </div>
-HTML
-
-puts "=" * 80
-puts "TEST: Sourcecode whitespace handling (False Positive Pattern)"
-puts "=" * 80
-
-# Test DOM algorithm
-puts "\n1. DOM ALGORITHM (Baseline):"
-puts "-" * 40
-dom_result = Canon::Comparison.equivalent?(expected, actual,
-                                           format: :html,
-                                           diff_algorithm: :dom,
-                                           verbose: false)
-puts "Result: #{dom_result ? '✅ PASS (no difference)' : '❌ FAIL (has difference)'}"
-
-# Test Semantic algorithm
-puts "\n2. SEMANTIC ALGORITHM (Under Test):"
-puts "-" * 40
-semantic_result = Canon::Comparison.equivalent?(expected, actual,
-                                                format: :html,
-                                                diff_algorithm: :semantic,
-                                                verbose: false)
-puts "Result: #{semantic_result ? '✅ PASS (no difference)' : '❌ FAIL (has difference)'}"
-
-# Analysis
-puts "\n#{'=' * 80}"
-if dom_result && !semantic_result
-  puts "❌ FALSE POSITIVE DETECTED"
-  puts "   DOM says: equivalent"
-  puts "   Semantic says: different"
-  puts "\nThis is the pattern we need to fix!"
-
-  # Get detailed diff
-  puts "\nDetailed semantic diff:"
-  Canon::Comparison.equivalent?(expected, actual,
-                                format: :html,
-                                diff_algorithm: :semantic,
-                                verbose: true)
-elsif !dom_result && semantic_result
-  puts "❌ FALSE NEGATIVE DETECTED"
-  puts "   DOM says: different"
-  puts "   Semantic says: equivalent"
-elsif dom_result && semantic_result
-  puts "✅ BOTH AGREE: No difference (correct match)"
-else
-  puts "✅ BOTH AGREE: Has difference (correct non-match)"
-end
-
-# Now test with a metadata element case
-puts "\n\n#{'=' * 80}"
-puts "TEST: Metadata element handling (Another False Positive Pattern)"
-puts "=" * 80
-
-expected2 = <<~HTML
-  <p id="X">
-    <span class="fmt-xref-label">Clause 1</span>
-    <a name="X">Content here</a>
-  </p>
-HTML
-
-actual2 = <<~HTML
-  <p id="X">
-    <span class="fmt-xref-label">Clause 1</span>
-    <bookmark id="X"/>
-    Content here
-  </p>
-HTML
-
-puts "\n1. DOM ALGORITHM:"
-dom2 = Canon::Comparison.equivalent?(expected2, actual2,
-                                     format: :html,
-                                     diff_algorithm: :dom,
-                                     verbose: false)
-puts "Result: #{dom2 ? '✅ PASS' : '❌ FAIL'}"
-
-puts "\n2. SEMANTIC ALGORITHM:"
-semantic2 = Canon::Comparison.equivalent?(expected2, actual2,
-                                          format: :html,
-                                          diff_algorithm: :semantic,
-                                          verbose: false)
-puts "Result: #{semantic2 ? '✅ PASS' : '❌ FAIL'}"
-
-puts "\n#{'=' * 80}"
-if dom2 && !semantic2
-  puts "❌ FALSE POSITIVE in metadata handling"
-elsif !dom2 && semantic2
-  puts "❌ FALSE NEGATIVE in metadata handling"
-elsif dom2 && semantic2
-  puts "✅ BOTH AGREE: equivalent"
-else
-  puts "✅ BOTH AGREE: different"
-end

data/scripts/test_size_limits.rb

@@ -1,99 +0,0 @@
-#!/usr/bin/env ruby
-# frozen_string_literal: true
-
-# Test script to verify size limit functionality
-
-require_relative "../lib/canon"
-require_relative "../lib/canon/config"
-require_relative "../lib/canon/commands/diff_command"
-
-puts "Testing Canon Size Limits"
-puts "=" * 60
-
-# Test 1: File size limit configuration
-puts "\n1. Testing file size limit configuration:"
-config = Canon::Config.instance
-puts "  Default max_file_size: #{config.xml.diff.max_file_size}"
-puts "  Expected: 5242880 (5MB)"
-
-# Test 2: Node count limit configuration
-puts "\n2. Testing node count limit configuration:"
-puts "  Default max_node_count: #{config.xml.diff.max_node_count}"
-puts "  Expected: 10000"
-
-# Test 3: Diff lines limit configuration
-puts "\n3. Testing diff lines limit configuration:"
-puts "  Default max_diff_lines: #{config.xml.diff.max_diff_lines}"
-puts "  Expected: 10000"
-
-# Test 4: ENV variable override
-puts "\n4. Testing ENV variable override:"
-ENV["CANON_MAX_FILE_SIZE"] = "1000000"
-ENV["CANON_MAX_NODE_COUNT"] = "5000"
-ENV["CANON_MAX_DIFF_LINES"] = "2000"
-
-# Reset config to pick up ENV vars
-Canon::Config.reset!
-config = Canon::Config.instance
-
-puts "  After setting ENV vars:"
-puts "    max_file_size: #{config.xml.diff.max_file_size} (expected: 1000000)"
-puts "    max_node_count: #{config.xml.diff.max_node_count} (expected: 5000)"
-puts "    max_diff_lines: #{config.xml.diff.max_diff_lines} (expected: 2000)"
-
-# Test 5: SizeLimitExceededError
-puts "\n5. Testing SizeLimitExceededError:"
-begin
-  error = Canon::SizeLimitExceededError.new(:file_size, 10_000_000, 5_242_880)
-  puts "  Created error: #{error.class}"
-  puts "  Message: #{error.message}"
-rescue StandardError => e
-  puts "  ERROR: #{e.class}: #{e.message}"
-end
-
-# Test 6: File size checking
-puts "\n6. Testing file size checking in diff command:"
-require "tempfile"
-
-# Create a small test file
-Tempfile.create(["test", ".xml"]) do |f1|
-  f1.write("<root><child>content</child></root>")
-  f1.flush
-
-  Tempfile.create(["test2", ".xml"]) do |f2|
-    f2.write("<root><child>different</child></root>")
-    f2.flush
-
-    # Set a very low limit to trigger error
-    ENV["CANON_MAX_FILE_SIZE"] = "10" # 10 bytes
-    Canon::Config.reset!
-
-    begin
-      cmd = Canon::Commands::DiffCommand.new(
-        format: :xml,
-        verbose: true,
-        color: false,
-      )
-      cmd.run(f1.path, f2.path)
-      puts "  ✗ Should have raised SizeLimitExceededError"
-    rescue Canon::SizeLimitExceededError => e
-      puts "  ✓ Correctly raised SizeLimitExceededError"
-      puts "    Message: #{e.message.lines.first.strip}"
-    rescue SystemExit => e
-      # abort() in diff_command causes SystemExit
-      # Check if it was due to size limit by checking stderr
-      puts "  ✓ File size check triggered (command aborted as expected)"
-    rescue StandardError => e
-      puts "  ✗ Unexpected error: #{e.class}: #{e.message}"
-    end
-  end
-end
-
-# Clean up ENV
-ENV.delete("CANON_MAX_FILE_SIZE")
-ENV.delete("CANON_MAX_NODE_COUNT")
-ENV.delete("CANON_MAX_DIFF_LINES")
-Canon::Config.reset!
-
-puts "\n#{'=' * 60}"
-puts "Size limits test completed!"

data/test_html_1.html

@@ -1,21 +0,0 @@
-<!DOCTYPE html>
-<html>
-<head>
-  <title>Test Page</title>
-  <!-- Version 1.0 stylesheet -->
-</head>
-<body>
-  <div class="container">
-    <!-- TODO: Add navigation menu -->
-    <h1>Welcome</h1>
-    <p>This is a test page.</p>
-    <!-- End of header section -->
-    
-    <section id="content">
-      <h2>Main Content</h2>
-      <!-- Important: This section is critical -->
-      <p>Lorem ipsum dolor sit amet.</p>
-    </section>
-  </div>
-</body>
-</html>

data/test_html_2.html

@@ -1,21 +0,0 @@
-<!DOCTYPE html>
-<html>
-<head>
-  <title>Test Page</title>
-  <!-- Version 2.0 updated styles -->
-</head>
-<body>
-  <div class="container">
-    <!-- DONE: Navigation menu added -->
-    <h1>Welcome</h1>
-    <p>This is a test page.</p>
-    <!-- End of navigation section -->
-    
-    <section id="content">
-      <h2>Main Content</h2>
-      <!-- Note: Section has been reviewed -->
-      <p>Lorem ipsum dolor sit amet.</p>
-    </section>
-  </div>
-</body>
-</html>

data/test_nokogiri.rb

@@ -1,33 +0,0 @@
-require "bundler/setup"
-require "nokogiri"
-
-html1 = "<html><body><p>Test</p></body></html>"
-html2 = "<html>\n\n<body>\n\n<p>Test</p>\n\n</body>\n\n</html>"
-
-puts "=== Nokogiri HTML5.fragment ==="
-frag1 = Nokogiri::HTML5.fragment(html1)
-frag2 = Nokogiri::HTML5.fragment(html2)
-
-puts "html1 children count: #{frag1.children.count}"
-frag1.children.each_with_index do |child, i|
-  puts "  Child #{i}: #{child.class} - #{child.name}"
-end
-
-puts "\nhtml2 children count: #{frag2.children.count}"
-frag2.children.each_with_index do |child, i|
-  puts "  Child #{i}: #{child.class} - #{child.name}"
-end
-
-puts "\n=== Nokogiri::XML.fragment ==="
-frag3 = Nokogiri::XML.fragment(html1)
-frag4 = Nokogiri::XML.fragment(html2)
-
-puts "html1 children count: #{frag3.children.count}"
-frag3.children.each_with_index do |child, i|
-  puts "  Child #{i}: #{child.class} - #{child.name}"
-end
-
-puts "\nhtml2 children count: #{frag4.children.count}"
-frag4.children.each_with_index do |child, i|
-  puts "  Child #{i}: #{child.class} - #{child.name}"
-end