crawlscope 0.8.0 → 0.8.1

data/test/crawlscope/reporter_test.rb

@@ -58,11 +58,11 @@ class CrawlscopeReporterTest < Minitest::Test
     assert_includes output, "Status: WARNINGS"
     refute_includes output, "Status: FAILED"
     assert_includes output, "Issues: 5 total (5 warnings)"
-    assert_includes output, "Summary:"
-    assert_includes output, "links / low_dofollow_inlinks: 4"
-    assert_includes output, "  - /page-1  inbound 1/2  sources: /source-1"
-    assert_includes output, "  - /page-4  inbound 1/2  sources: /source-4"
-    assert_includes output, "metadata / missing_title: 1"
+    refute_includes output, "Summary:"
+    assert_includes output, "Links: Too few incoming links without nofollow (4 warnings)"
+    assert_includes output, "  - /page-1  incoming links without nofollow: 1; minimum 2\n      linked from: /source-1"
+    assert_includes output, "  - /page-4  incoming links without nofollow: 1; minimum 2\n      linked from: /source-4"
+    assert_includes output, "Metadata: Missing title (1 warning)"
     refute_includes output, "Severity:"
     refute_includes output, "Category:"
     refute_includes output, "... 1 more"
@@ -90,7 +90,7 @@ class CrawlscopeReporterTest < Minitest::Test
     assert_includes output, "Issues: 2 total (1 error, 1 warning)"
   end
 
-  def test_limits_large_issue_groups
+  def test_reports_every_issue_in_large_groups
     io = StringIO.new
     issues = Crawlscope::IssueCollection.new
     21.times do |index|
@@ -116,10 +116,10 @@ class CrawlscopeReporterTest < Minitest::Test
 
     output = io.string
 
-    assert_includes output, "links / low_dofollow_inlinks: 21"
-    assert_includes output, "  - /page-20  inbound 1/2"
-    refute_includes output, "  - /page-21"
-    assert_includes output, "  ... 1 more"
+    assert_includes output, "Links: Too few incoming links without nofollow (21 warnings)"
+    assert_includes output, "  - /page-20  incoming links without nofollow: 1; minimum 2"
+    assert_includes output, "  - /page-21"
+    refute_includes output, "  ... 1 more"
   end
 
   def test_reports_ratio_with_enough_precision_to_show_threshold_difference
@@ -144,7 +144,7 @@ class CrawlscopeReporterTest < Minitest::Test
 
     Crawlscope::Reporter.new(io: io).report(result)
 
-    assert_includes io.string, "ratio 0.249/0.250"
+    assert_includes io.string, "unique words: 24.9%; minimum 25%"
   end
 
   def test_reports_source_details_on_one_line
@@ -173,9 +173,9 @@ class CrawlscopeReporterTest < Minitest::Test
 
     output = io.string
 
-    assert_includes output, "sitemaps / indexable_page_missing_from_sitemap: 4"
-    assert_includes output, "  - /overview-1  indexable internal page is missing from sitemap  source: /source-1"
-    assert_includes output, "  - /overview-4  indexable internal page is missing from sitemap  source: /source-4"
+    assert_includes output, "Sitemaps: Linked pages missing from sitemap (4 warnings)"
+    assert_includes output, "  - /overview-1  linked page is missing from sitemap\n      linked from: /source-1"
+    assert_includes output, "  - /overview-4  linked page is missing from sitemap\n      linked from: /source-4"
   end
 
   def test_reports_server_timing_coverage_percentiles_signals_and_worst_pages
@@ -207,17 +207,188 @@ class CrawlscopeReporterTest < Minitest::Test
     output = io.string
     assert_includes output, "Server Timing:"
     assert_includes output, "Coverage: 3/3 pages (100.0%); durations on 2 pages"
-    assert_includes output, "Duration metrics (dur; milliseconds assumed):"
+    assert_includes output, "Response times (ms):"
     assert_includes output, "total: 2 samples / 2 pages; avg 200ms; p50 200ms; p95 290ms; max 300ms"
     assert_includes output, 'db "Primary": 1 sample / 1 page'
     assert_includes output, 'cache "HIT": 1 sample / 1 page'
-    assert_includes output, "Worst pages:"
+    assert_includes output, "Pages above 50 ms:"
     assert_includes output, "/slow: 300ms (total)"
     assert_includes output, "Ignored malformed entries: 1"
   end
 
+  def test_reports_redirect_destination_once_and_keeps_external_origins
+    [:sitemap_redirect_url, :redirected_page, :internal_link_redirects].each do |code|
+      output = report_issues({code: code, details: {final_url: "https://example.com/new?lang=en#top", status: 200}})
+
+      assert_includes output, "redirects to /new?lang=en#top"
+      assert_equal 1, output.scan("/new?lang=en#top").size
+      refute_includes output, "status 200"
+      refute_includes output, "final:"
+    end
+
+    ["https://other.example/new", "http://example.com/new", "https://example.com:8443/new"].each do |destination|
+      output = report_issues({code: :sitemap_redirect_url, details: {final_url: destination, status: 200}})
+      assert_includes output, "redirects to #{destination}"
+    end
+  end
+
+  def test_reports_canonical_target_and_explains_sitemap_mismatch
+    ["https://example.com/preferred?lang=en", "/preferred?lang=en"].each do |canonical|
+      output = report_issues({code: :non_canonical_page_in_sitemap, category: :sitemaps, details: {canonical: canonical}})
+      assert_includes output, "/page  sitemap lists this URL, but its canonical points to /preferred?lang=en"
+    end
+
+    output = report_issues({code: :canonical_mismatch, details: {canonical: "https://other.example/page"}})
+    assert_includes output, "canonical points to a different URL: https://other.example/page"
+  end
+
+  def test_reports_real_schema_errors_on_separate_lines_without_raw_json
+    errors = Crawlscope::SchemaRegistry.default.validate({"@type" => "Article", "headline" => "x" * 111, "author" => "Name"})
+    output = report_issues({code: :structured_data_schema_error, category: :structured_data, details: {source: "json-ld", errors: errors}})
+
+    assert_includes output, "Structured data: Schema errors (1 warning)"
+    assert_includes output, "  - /page  JSON-LD\n      Article.headline: 111 characters; maximum 110\n      Article.author: must be object (got string)"
+    refute_includes output, "in schema"
+    refute_includes output, '"field":'
+    assert_includes errors.first[:issue], "in schema"
+  end
+
+  def test_reports_link_failures_without_repeating_status_or_sources
+    output = report_issues(
+      {code: :broken_internal_link, message: "broken internal link (HTTP 404, sources: https://example.com/source)", details: {status: 404, source_urls: ["https://example.com/source"]}},
+      {code: :unresolved_internal_link, details: {error: "timeout", source_urls: ["https://example.com/source"]}},
+      {code: :internal_link_redirects, details: {final_url: "https://example.com/new", source_urls: ["https://example.com/source"], status: 200}}
+    )
+
+    assert_includes output, "linked URL returns HTTP 404\n      linked from: /source"
+    assert_equal 1, output.scan("404").size
+    assert_includes output, "cannot check linked URL: timeout\n      linked from: /source"
+    assert_includes output, "redirects to /new (final HTTP 200)\n      linked from: /source"
+    refute_includes output, "https://example.com/source"
+  end
+
+  def test_reports_canonical_status_with_both_relevant_urls
+    output = report_issues(
+      {code: :canonical_points_to_redirect, details: {canonical: "https://example.com/old", final_url: "https://example.com/new", status: 200}},
+      {code: :canonical_points_to_error, details: {canonical: "https://example.com/missing", status: 404}},
+      {code: :canonical_no_internal_inlinks, message: "canonical URL has no incoming internal links without nofollow", details: {source_url: "https://example.com/article"}}
+    )
+
+    assert_includes output, "canonical /old redirects to /new"
+    assert_includes output, "canonical /missing returns HTTP 404"
+    assert_includes output, "      canonical on: /article"
+    refute_includes output, "linked from: /article"
+  end
+
+  def test_reports_errors_before_larger_warning_groups
+    warnings = 3.times.map { |index| {code: :missing_title, category: :metadata, url: "https://example.com/#{index}"} }
+    output = report_issues(*warnings, {code: :fetch_failed, category: :crawl, severity: :error, message: "timeout"})
+
+    assert_operator output.index("Crawl: Fetch failed"), :<, output.index("Metadata: Missing title")
+    refute_includes output, "metadata / missing_title"
+  end
+
+  def test_reports_full_duplicate_values_and_every_url
+    urls = 5.times.map { |index| "https://example.com/page-#{index}" }
+    value = "A long description " * 20
+    details = {value: value, urls: urls}
+    output = report_issues({code: :duplicate_meta_description, category: :uniqueness, details: details})
+
+    assert_includes output, "same meta description:"
+    assert_includes output, value
+    urls.each { |url| assert_includes output, "      page: #{URI(url).path}" }
+    refute_includes output, "more)"
+    assert_equal value, details[:value]
+    assert_equal 5, details[:urls].size
+  end
+
+  def test_reports_measurements_with_units_and_limits
+    output = report_issues(
+      {code: :low_visible_text_ratio, details: {ratio: 0.079, threshold: 0.08}},
+      {code: :thin_visible_text, details: {word_count: 40, minimum: 250}},
+      {code: :near_duplicate_content, details: {similarity: 0.925, threshold: 0.9, urls: ["https://example.com/a", "https://example.com/b"]}},
+      {code: :near_duplicate_scan_skipped, details: {page_count: 300, max_pages: 250}}
+    )
+
+    assert_includes output, "visible text / HTML bytes: 7.9%; minimum 8%"
+    assert_includes output, "visible words: 40; minimum 250"
+    assert_includes output, "text similarity: 92.5%; threshold 90%\n      page: /a\n      page: /b"
+    assert_includes output, "similar-page check skipped: 300 pages; limit 250"
+  end
+
+  def test_reports_all_source_and_target_urls_on_labeled_lines
+    sources = 6.times.map { |index| "https://example.com/source-#{index}" }
+    targets = 6.times.map { |index| "https://example.com/target-#{index}" }
+    output = report_issues({code: :nofollow_internal_outlinks, details: {source_url: sources.first, source_urls: sources, target_urls: targets}})
+
+    sources.each { |url| assert_includes output, "      linked from: #{URI(url).path}\n" }
+    targets.each { |url| assert_includes output, "      links to: #{URI(url).path}\n" }
+    assert_equal 1, output.scan("linked from: /source-0").size
+    refute_includes output, "more"
+  end
+
+  def test_reports_all_timed_pages_and_full_descriptions
+    description = "A detailed metric description " * 5
+    pages = 12.times.map { |index| page("/timed-#{index}", server_timing: %(total;dur=#{index + 60};desc="#{description}")) }
+    result = Crawlscope::Result.new(base_url: "https://example.com", sitemap_path: "/sitemap.xml", urls: pages.map(&:url), pages: pages, issues: Crawlscope::IssueCollection.new)
+    io = StringIO.new
+    Crawlscope::Reporter.new(io: io).report(result)
+
+    pages.each { |item| assert_includes io.string, "#{URI(item.url).path}:" }
+    assert_includes io.string, description
+  end
+
+  def test_length_rows_do_not_repeat_the_field_or_limit_from_the_heading
+    output = report_issues(
+      {code: :meta_description_too_long, category: :metadata, message: "meta description: 184 characters; maximum 160", details: {length: 184}},
+      {code: :meta_description_too_short, category: :metadata, details: {length: 40, minimum: 110}},
+      {code: :title_too_long, category: :metadata, details: {length: 80}}
+    )
+
+    assert_includes output, "Metadata: Meta description exceeds 160 characters (1 warning)\n  - /page  184 characters"
+    assert_includes output, "Metadata: Meta description below 110 characters (1 warning)\n  - /page  40 characters"
+    assert_includes output, "Metadata: Title exceeds 72 characters (1 warning)\n  - /page  80 characters"
+    refute_includes output, "meta description:"
+    refute_includes output, "maximum 160"
+  end
+
+  def test_lists_only_pages_strictly_above_50_milliseconds
+    pages = [page("/fast", server_timing: "total;dur=49"), page("/boundary", server_timing: "total;dur=50"), page("/slow", server_timing: "total;dur=50.001")]
+    result = Crawlscope::Result.new(base_url: "https://example.com", sitemap_path: "/sitemap.xml", urls: pages.map(&:url), pages: pages, issues: Crawlscope::IssueCollection.new)
+    io = StringIO.new
+    Crawlscope::Reporter.new(io: io).report(result)
+
+    assert_includes io.string, "Pages above 50 ms:\n    /slow: 50.001ms (total)"
+    refute_includes io.string, "/fast:"
+    refute_includes io.string, "/boundary:"
+    assert_includes io.string, "Coverage: 3/3 pages"
+    assert_includes io.string, "total: 3 samples / 3 pages"
+  end
+
+  def test_omits_slow_page_section_when_all_pages_are_at_or_below_50_milliseconds
+    pages = [page("/boundary", server_timing: "total;dur=50")]
+    result = Crawlscope::Result.new(base_url: "https://example.com", sitemap_path: "/sitemap.xml", urls: pages.map(&:url), pages: pages, issues: Crawlscope::IssueCollection.new)
+    io = StringIO.new
+    Crawlscope::Reporter.new(io: io).report(result)
+
+    refute_includes io.string, "Pages above"
+    assert_includes io.string, "Server Timing:"
+  end
+
   private
 
+  def report_issues(*attributes, base_url: "https://example.com")
+    issues = Crawlscope::IssueCollection.new
+    attributes.each do |values|
+      defaults = {severity: :warning, category: :links, url: "#{base_url}/page", message: "original message", details: {}}
+      issues.add(**defaults.merge(values))
+    end
+    result = Crawlscope::Result.new(base_url: base_url, sitemap_path: "/sitemap.xml", urls: [], pages: [], issues: issues)
+    io = StringIO.new
+    Crawlscope::Reporter.new(io: io).report(result)
+    io.string
+  end
+
   def page(path = "/", server_timing: nil)
     url = "https://example.com#{path}"
     headers = {}

data/test/crawlscope/run_test.rb

@@ -185,7 +185,7 @@ class CrawlscopeRunTest < Minitest::Test
     assert_equal ["https://example.com"], JSON.parse(File.read(report_path)).fetch("results").keys
     assert_includes output.string, "JavaScript mode enabled (Ferrum)"
     assert_includes output.string, "Validating JSON-LD on 1 URL(s)"
-    assert_includes output.string, "All valid!"
+    assert_includes output.string, "Validation: OK"
     assert_includes output.string, "All 1 URLs passed validation."
   ensure
     FileUtils.rm_rf(report_dir) if report_dir

data/test/crawlscope/schema_registry_test.rb

@@ -46,6 +46,39 @@ class CrawlscopeSchemaRegistryTest < Minitest::Test
     assert registry.registered?("VideoObject")
   end
 
+  def test_length_errors_include_character_count_without_copying_the_value
+    error = Crawlscope::SchemaRegistry.default.validate({"@type" => "Article", "headline" => "é" * 111}).first
+
+    assert_equal 111, error[:length]
+    assert_equal "headline", error[:field]
+    assert_includes error[:issue], "maximum string length of 110"
+    assert_equal [:field, :issue, :type, :length], error.keys
+  end
+
+  def test_measures_string_fields_inside_nested_arrays
+    schema = {
+      type: "object",
+      properties: {
+        entries: {type: "array", items: {type: "object", properties: {name: {type: "string", maxLength: 3}}}}
+      }
+    }
+    registry = Crawlscope::SchemaRegistry.new(schemas: {"Thing" => schema})
+    errors = registry.validate({"@type" => "Thing", "entries" => [{"name" => "ok"}, {"name" => "éééé"}]})
+
+    assert_equal 1, errors.size
+    assert_equal "entries/1/name", errors.first[:field]
+    assert_equal 4, errors.first[:length]
+  end
+
+  def test_measures_each_graph_items_headline_independently
+    errors = Crawlscope::SchemaRegistry.default.validate({"@graph" => [
+      {"@type" => "Article", "headline" => "a" * 111},
+      {"@type" => "Article", "headline" => "b" * 125}
+    ]})
+
+    assert_equal [111, 125], errors.map { |error| error[:length] }
+  end
+
   def test_web_application_review_requires_review_rating
     errors = Crawlscope::SchemaRegistry.default.validate(
       {

data/test/crawlscope/structured_data_error_formatter_test.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class CrawlscopeStructuredDataErrorFormatterTest < Minitest::Test
+  def test_formats_missing_root_and_nested_fields_from_real_schema_errors
+    registry = Crawlscope::SchemaRegistry.default
+    errors = registry.validate({"@type" => "WebApplication", "name" => "App", "review" => {"@type" => "Review"}})
+
+    assert_equal "WebApplication.review/reviewRating: is required", format_error(errors.first)
+    assert_equal "Article.headline: is required", format_error(registry.validate({"@type" => "Article"}).first)
+  end
+
+  def test_preserves_unknown_constraints_without_schema_noise
+    error = {"field" => "price", "type" => "Product", "issue" => "The property '#/price' must satisfy a custom constraint in schema 3bdea3a8-461f-5eae-9d73-3243b48b4bc8"}
+
+    assert_equal "Product.price: must satisfy a custom constraint", format_error(error)
+    assert_equal "$: Unknown error", format_error({})
+  end
+
+  def test_formats_custom_minimum_length_constraint
+    registry = Crawlscope::SchemaRegistry.new(schemas: {"Thing" => {type: "object", properties: {name: {type: "string", minLength: 3}}}})
+    error = registry.validate({"@type" => "Thing", "name" => "x"}).first
+
+    assert_equal "Thing.name: 1 character; minimum 3", format_error(error)
+  end
+
+  def test_formats_measured_headline_length_with_symbol_or_json_keys
+    error = Crawlscope::SchemaRegistry.default.validate({"@type" => "Article", "headline" => "é" * 111}).first
+
+    assert_equal "Article.headline: 111 characters; maximum 110", format_error(error)
+    assert_equal "Article.headline: 111 characters; maximum 110", format_error(JSON.parse(JSON.generate(error)))
+  end
+
+  def test_formats_legacy_length_errors_without_a_measurement
+    error = {type: "Article", field: "headline", issue: "The property '#/headline' was not of a maximum string length of 110"}
+
+    assert_equal "Article.headline: exceeds 110 characters", format_error(error)
+  end
+
+  private
+
+  def format_error(error)
+    Crawlscope::StructuredData::ErrorFormatter.format(error)
+  end
+end

data/test/crawlscope/structured_data_reporter_test.rb

@@ -29,4 +29,30 @@ class CrawlscopeStructuredDataReporterTest < Minitest::Test
     assert_includes output, "headline: is required"
     assert_includes output, "/tmp/structured_data_report.json"
   end
+
+  def test_formats_real_schema_errors_in_summary_and_detailed_reports
+    errors = Crawlscope::SchemaRegistry.default.validate({"@type" => "Article", "headline" => "x" * 111})
+    result = Crawlscope::StructuredData::Audit::Outcome.new(entries: [
+      Crawlscope::StructuredData::Audit::Page.new(
+        url: "https://example.com/article", status: 200,
+        structured_items: [{source: "json-ld", data: {"@type" => "Article"}}],
+        errors: [{type: "Article", source: "json-ld", errors: errors}],
+        fetch_error: nil, content_type: "text/html", skipped_reason: nil
+      )
+    ])
+    io = StringIO.new
+    reporter = Crawlscope::StructuredData::Reporter.new(io: io)
+
+    reporter.report(result)
+    assert_includes io.string, "JSON-LD:\n      - Article.headline: 111 characters; maximum 110"
+    refute_includes io.string, "in schema"
+
+    io.truncate(0)
+    io.rewind
+    reporter.details(result, debug: false, renderer: :http)
+    assert_includes io.string, "Validation: FAILED\n  JSON-LD:\n    - Article.headline: 111 characters; maximum 110"
+    refute_includes io.string, "=" * 80
+    refute_includes io.string, "in schema"
+    assert_includes errors.first[:issue], "in schema"
+  end
 end

data/test/crawlscope/structured_data_rule_test.rb

@@ -31,6 +31,8 @@ class CrawlscopeStructuredDataRuleTest < Minitest::Test
 
     assert_equal [:structured_data_schema_error], issues.to_a.map(&:code)
     assert_includes issues.to_a.first.message, "headline"
+    assert_equal "JSON-LD Article.headline: is required", issues.to_a.first.message
+    assert_includes issues.to_a.first.details[:errors].first[:issue], "in schema"
   end
 
   def test_reports_parse_errors_for_invalid_json_ld

data/test/crawlscope/uniqueness_rule_test.rb

@@ -44,6 +44,49 @@ class CrawlscopeUniquenessRuleTest < Minitest::Test
     assert_operator issue.details[:similarity], :>=, issue.details[:threshold]
   end
 
+  def test_does_not_report_redirect_aliases_as_duplicate_pages
+    pages = [
+      page(url: "https://example.com/old", final_url: "https://example.com/current"),
+      page(url: "https://example.com/alias", final_url: "https://example.com/current"),
+      page(url: "https://example.com/current")
+    ]
+    issues = Crawlscope::IssueCollection.new
+
+    Crawlscope::Rules::Uniqueness.new.call(urls: pages.map(&:url), pages: pages, issues: issues, context: {})
+
+    assert_empty issues.to_a
+  end
+
+  def test_reports_direct_duplicate_pages_without_including_redirect_aliases
+    pages = [
+      page(url: "https://example.com/old", final_url: "https://example.com/a"),
+      page(url: "https://example.com/a"),
+      page(url: "https://example.com/b")
+    ]
+    issues = Crawlscope::IssueCollection.new
+
+    Crawlscope::Rules::Uniqueness.new.call(urls: pages.map(&:url), pages: pages, issues: issues, context: {})
+
+    assert_equal 4, issues.size
+    issues.each do |issue|
+      assert_equal ["https://example.com/a", "https://example.com/b"], issue.details[:urls]
+    end
+  end
+
+  def test_excludes_redirects_from_near_duplicate_checks_and_scan_limit
+    pages = [
+      page(url: "https://example.com/old", final_url: "https://example.com/other", content: near_duplicate_content("reliable")),
+      page(url: "https://example.com/current", content: near_duplicate_content("dependable"))
+    ]
+
+    [Crawlscope::Rules::Uniqueness.new, Crawlscope::Rules::Uniqueness.new(max_near_duplicate_pages: 1)].each do |rule|
+      issues = Crawlscope::IssueCollection.new
+      rule.call(urls: pages.map(&:url), pages: pages, issues: issues, context: {})
+
+      assert_empty issues.to_a
+    end
+  end
+
   def test_skips_near_duplicate_scan_when_page_count_exceeds_limit
     issues = Crawlscope::IssueCollection.new
     rule = Crawlscope::Rules::Uniqueness.new(max_near_duplicate_pages: 1)
@@ -72,7 +115,7 @@ class CrawlscopeUniquenessRuleTest < Minitest::Test
     TEXT
   end
 
-  def page(url:, content: nil, canonical: nil)
+  def page(url:, content: nil, canonical: nil, final_url: url)
     repeated_text = content || ("Useful content " * 30).strip
     canonical_tag = canonical ? %(<link rel="canonical" href="#{canonical}">) : ""
     body = <<~HTML
@@ -91,8 +134,8 @@ class CrawlscopeUniquenessRuleTest < Minitest::Test
     Crawlscope::Page.new(
       url: url,
       normalized_url: url,
-      final_url: url,
-      normalized_final_url: url,
+      final_url: final_url,
+      normalized_final_url: final_url,
       status: 200,
       headers: {"content-type" => "text/html"},
       body: body,

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: crawlscope
 version: !ruby/object:Gem::Version
-  version: 0.8.0
+  version: 0.8.1
 platform: ruby
 authors:
 - Paulo Fidalgo
@@ -257,6 +257,7 @@ files:
 - lib/crawlscope/structured_data/audit.rb
 - lib/crawlscope/structured_data/check.rb
 - lib/crawlscope/structured_data/document.rb
+- lib/crawlscope/structured_data/error_formatter.rb
 - lib/crawlscope/structured_data/report.rb
 - lib/crawlscope/structured_data/reporter.rb
 - lib/crawlscope/structured_data/writer.rb
@@ -290,6 +291,7 @@ files:
 - test/crawlscope/sitemap_test.rb
 - test/crawlscope/structured_data_audit_test.rb
 - test/crawlscope/structured_data_document_test.rb
+- test/crawlscope/structured_data_error_formatter_test.rb
 - test/crawlscope/structured_data_report_test.rb
 - test/crawlscope/structured_data_reporter_test.rb
 - test/crawlscope/structured_data_rule_test.rb
@@ -328,7 +330,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.16
+rubygems_version: 4.0.20
 specification_version: 4
 summary: Audit sitemap URLs for metadata, structured data, uniqueness, and links
 test_files: []