svg_conform 0.2.4 → 0.2.6

data/docs/api_reference.adoc

@@ -336,10 +336,28 @@ Check if document is valid.
 
 ===== has_errors?
 
-Check if errors were found.
+Check if errors or validity errors were found (the same condition as
+`valid?` being false).
 
 **Returns**: `Boolean`
 
+===== infos / info_count
+
+Informational diagnostics (for example external reference notices) and their
+count. Infos never affect `valid?`.
+
+===== to_lens_core_report(timestamp: nil)
+
+Returns the canonical `LensCore::Report` for this result. Errors and validity
+errors are both severity `error`. The timestamp is included only when the
+caller supplies one. See xref:diagnostics.adoc[Diagnostics].
+
+===== to_h / to_json / to_s
+
+Project the canonical report. `to_h` is symbol-keyed. `file`,
+`fixes_applied`, `fixable` and `reference_manifest` are retained as
+compatibility extensions.
+
 ===== has_warnings?
 
 Check if warnings were found.

data/docs/cli_guide.adoc

@@ -125,6 +125,18 @@ Available profiles:
 * `metanorma` - Metanorma requirements
 * `lucid` - Lucid profile
 * `no_external_css` - No external CSS
+* `svg_1_1_full_static` - SVG 1.1 Full document grammar, static processing (see link:profiles.adoc#svg-1-1-full-static-profile[profiles])
+* `svg_2_secure_static` - SVG 2 secure-static resource rules (opt-in; see link:profiles.adoc#svg-2-secure-static-profile[profiles])
+
+Examples:
+
+* `svg_conform check drawing.svg --profile svg_1_1_full_static`
+* SVG 2 secure-static:
+
+[source,sh]
+----
+svg_conform check drawing.svg --profile svg_2_secure_static --format json
+----
 
 ==== Output format (single file)
 
@@ -133,9 +145,9 @@ Output format for single file mode (default: `table`)
 +
 Options:
 +
-* `table` - Human-readable table (default)
-* `json` - JSON format
-* `yaml` - YAML format
+* `table` - Human-readable text (default); an alias for the LensCore human renderer
+* `json` - LensCore diagnostics JSON (schema version 1)
+* `yaml` - LensCore diagnostics YAML (schema version 1)
 
 `--output=FILE` or `-o`::
 Save report to file instead of stdout
@@ -403,67 +415,45 @@ fi
 
 ==== Table format (default)
 
-Human-readable table with error summary:
+Plain text rendered by LensCore from the canonical report. Errors, warnings
+and infos all appear; see xref:diagnostics.adoc[Diagnostics].
 
 [source,text]
 ----
-SVG Validation Report
-==================================================
-File: file.svg
-Profile: metanorma
-Valid: ✗
-Total Errors: 2
-
-Validation Errors:
+svg_conform 0.2.4, profile metanorma
+INVALID: 1 error, 0 warnings, 1 info
 
-• Viewbox is required
-    at svg
+error  viewbox_required  (viewbox_violation)
+  at /svg[1]
+  Viewbox is required
+  fix: Add missing viewBox attribute
 
-• External images are not allowed
-    at image
+info  link_validation  (reference_violation)
+  at /svg[1]/a[1]
+  External reference: https://example.com/page
 ----
 
 ==== JSON format
 
-Machine-readable JSON using lutaml-model:
+The LensCore diagnostics report, schema version 1 (see
+xref:diagnostics.adoc[Diagnostics]). No timestamp is emitted by the CLI.
 
 [source,json]
 ----
 {
-  "filename": "file.svg",
-  "profile": "metanorma",
+  "schema_version": 1,
+  "producer": { "name": "svg_conform", "version": "0.2.4" },
+  "profile": { "id": "metanorma", "citations": [] },
   "valid": false,
-  "errors": {
-    "total_count": 2,
-    "issues": [
-      {
-        "requirement_id": "viewbox_required",
-        "message": "Viewbox is required",
-        "element": "svg",
-        "line_number": 1
-      }
-    ]
-  }
+  "summary": { "errors": 1, "warnings": 0, "infos": 1 },
+  "diagnostics": [ ... ],
+  "file": "file.svg"
 }
 ----
 
 ==== YAML format
 
-Machine-readable YAML using lutaml-model:
-
-[source,yaml]
-----
-filename: file.svg
-profile: metanorma
-valid: false
-errors:
-  total_count: 2
-  issues:
-  - requirement_id: viewbox_required
-    message: Viewbox is required
-    element: svg
-    line_number: 1
-----
+The same report and key order as the JSON format, rendered as YAML.
 
 ==== Batch report format
 

data/docs/diagnostics.adoc

@@ -0,0 +1,73 @@
+= SvgConform Diagnostics
+:toc: left
+:source-highlighter: rouge
+
+== Purpose
+
+SvgConform reports one validation result as one
+https://github.com/claricle/lens_core[LensCore] diagnostics report (schema
+version 1). JSON, YAML and human output all render from that report.
+
+== Producing a report
+
+[source,ruby]
+----
+result = SvgConform::Validator.new.validate_file("a.svg", profile: :svg_1_2_rfc)
+
+report = result.to_lens_core_report                       # LensCore::Report
+report = result.to_lens_core_report(timestamp: Time.now)  # timestamp only if given
+
+LensCore::Renderers::Json.render(report)
+LensCore::Renderers::Yaml.render(report)
+LensCore::Renderers::Human.render(report)
+----
+
+`SvgConform::Diagnostics::LensCoreAdapter.call(result, filename: nil,
+timestamp: nil)` is the single entry point behind these.
+
+== Mapping
+
+[cols="2,1,3"]
+|===
+| svg_conform source | Severity | Kind
+
+| `errors` | `error` | the issue's violation type, else `validation`
+| `validity_errors` | `error` | `validity`
+| `warnings` | `warning` | the issue's violation type, else `validation`
+| `infos` | `info` | the issue's violation type, else `notice`
+|===
+
+An `unknown_violation` type counts as absent. Order within each channel is
+preserved and channels are emitted in the order above. Requirement IDs are
+the explicit IDs on the issues; infos created through
+`ValidationContext#add_notice(requirement_id:)` and
+`#add_external_reference_notice(requirement_id:)` carry their requirement's
+ID. `valid` is true only when there are no errors and no validity errors.
+
+Each diagnostic carries `location` (XML line, column and element path when
+known), `remediation` (the suggested action when remediable) and `context`
+(`element`, remediation flags, and the issue `data`). Issue data must be
+JSON-safe; symbols become strings, and any other object raises
+`SvgConform::Diagnostics::UnsupportedContextError`.
+
+== Citations
+
+`Profile` accepts `specification_uri` and `specification_label`; every
+requirement accepts `citation_uri` and `citation_label`. Both are read from
+profile YAML and become LensCore citations on the report profile and on
+diagnostics for that requirement. Existing profiles may omit them.
+
+== Transition
+
+For one transition the previous surfaces remain callable:
+
+* `ValidationResult#to_h`, `#to_json`, `#to_s(format:)` project the canonical
+  report, with `file`, `fixes_applied`, `fixable` and `reference_manifest` as
+  compatibility extensions.
+* `ConformanceReport.from_svg_conform_result` (deprecated) builds the
+  canonical report first and projects its errors and warnings into the legacy
+  YAML shape. `use_svgcheck_mapping:` and `from_svgcheck_result` keep their
+  signatures; svgcheck filtering happens after canonical construction and
+  never mutates the report.
+* `svg_conform check --format table|json|yaml` renders through LensCore;
+  `table` is an alias for the human renderer.

data/docs/lens_core_handoff.adoc

@@ -0,0 +1,84 @@
+= LensCore v1 freeze candidate: adoption handoff
+:toc: left
+:source-highlighter: rouge
+
+== Purpose
+
+This page lets another lens adopt https://github.com/claricle/lens_core[LensCore]
+without reading any SVG code. It names the exact immutable commits and digests.
+Nothing here is tagged, released or published.
+
+== Pinned facts
+
+[cols="2,5"]
+|===
+| LensCore freeze commit | `d8903de61dec5b600853e1d605a712cc83f99c41` (claricle/lens_core#4 merge commit)
+| Schema path | `schemas/lens-diagnostics-v1.json`
+| Schema SHA-256 | `90f0976166aaa88417d3eec59cab8288e085b89230a9521e431169acb3e87cba`
+| Schema version | `1` (`LensCore::SCHEMA_VERSION`)
+| Golden manifest | `spec/fixtures/v1/golden/manifest.yml`
+| Contract commit used to render the goldens | `98c21c82bc97e3c8c4038048acdcec4a177c5f7c` (schema and `lib/` are identical at the freeze commit)
+| svg_conform producer commit named by the manifest | `5bf0f80af2a80bb5fd9f8a68cc95e470ae43e5d0`
+| svg_conform pin | `Gemfile` and `Gemfile.lock` resolve LensCore to the freeze commit above
+|===
+
+== Adopting
+
+Pin the exact commit, never a branch:
+
+[source,ruby]
+----
+gem "lens_core", git: "https://github.com/claricle/lens_core.git",
+                 ref: "d8903de61dec5b600853e1d605a712cc83f99c41"
+----
+
+Canonical calls:
+
+[source,ruby]
+----
+report = LensCore::Parsers::Json.parse(File.binread("report.json"))  # or Parsers::Yaml
+LensCore::Renderers::Json.render(report)   # canonical bytes
+LensCore::Renderers::Yaml.render(report)
+LensCore::Renderers::Human.render(report)
+----
+
+Rendering a parsed canonical golden returns the input bytes exactly. Timestamps
+are omitted unless the producer passes one.
+
+== Compatibility and errors
+
+* A `schema_version` other than `1` raises `LensCore::UnsupportedVersionError`;
+  a non-integer one raises `LensCore::SchemaError`.
+* Within version 1 consumers accept new `kind` values and unknown members.
+  Removing a member, changing its meaning, or adding a `severity` or location
+  `type` is a new schema version.
+* Other failures are `LensCore::ParseError`, `UnsafeYamlError`,
+  `InvalidEncodingError` and `SchemaError` (with the failing path).
+* `summary` is derived and checked on parse; `valid: true` with an error is
+  rejected. The full rules are in LensCore `docs/diagnostics-v1.adoc`.
+
+== Evidence completed
+
+* Three real svg_conform exports in `spec/fixtures/v1/golden/svg_conform/`:
+  SVG 1.1 invalid CSS grammar, SVG 2 external reference, and a four-channel
+  report (error, validity error, warning, info) built through the public
+  `SvgConform::Diagnostics::LensCoreAdapter`.
+* Each golden validates against the schema, parses, and renders byte for byte;
+  summary counts equal the diagnostics.
+* `spec/fixtures/host_app/` reads the whole golden directory using LensCore
+  alone (no svg_conform, no other lens).
+* `script/refresh_svg_goldens PATH_TO_SVG_CONFORM` regenerates the three SVG
+  goldens from a checkout at the manifest's producer commit.
+
+== Not evidence
+
+`spec/fixtures/v1/golden/examples/binary-location.json` is a format-neutral
+contract example of the binary location form. It is not PNG, EMF or PostScript
+implementation evidence; no lens other than svg_conform has adopted LensCore.
+
+== Future work, outside this issue
+
+* EMF, PNG and PostScript adapters.
+* Tagging and publishing a LensCore gem, and replacing every Git pin with a
+  released constraint.
+* Migrating other lenses.

data/docs/profiles.adoc

@@ -17,7 +17,46 @@ Each profile consists of:
 
 == Available profiles
 
-SvgConform includes 5 built-in profiles, each designed for different use cases and compliance standards.
+SvgConform includes built-in profiles, each designed for different use cases and compliance standards.
+
+[[svg-1-1-full-static-profile]]
+=== SVG 1.1 Full static profile (`:svg_1_1_full_static`)
+
+**Purpose**: Opt-in check that a document is a conforming SVG 1.1 (Second Edition) Full document under static processing. It validates the Recommendation's document grammar; it is not an element allow-list.
+
+**Specification**: https://www.w3.org/TR/2011/REC-SVG11-20110816/[SVG 1.1 Second Edition]
+
+**Requirements** (each reports under its own ID and carries its normative citation in issues and LensCore reports):
+
+[cols="2,4,3"]
+|===
+| ID | Rule | Citation
+
+| `svg11.document.xml` | Well-formed XML; the original declaration, doctype and processing instructions are provable from the source | https://www.w3.org/TR/2011/REC-SVG11-20110816/conform.html#ConformingSVGDocuments[Conforming SVG Documents]
+| `svg11.document.root` | Document element is `svg` in `http://www.w3.org/2000/svg` | https://www.w3.org/TR/2011/REC-SVG11-20110816/struct.html#SVGElement[The svg element]
+| `svg11.document.version` | Root declares `version="1.1"` | https://www.w3.org/TR/2011/REC-SVG11-20110816/struct.html#SVGElementVersionAttribute[version attribute]
+| `svg11.document.grammar` | Elements, attributes and content models validate against the vendored flat DTD (`data/svg_1_1/svg11-flat-20110816.dtd`) after the Appendix G.2 foreign-namespace transform, applied to a copy | https://www.w3.org/TR/2011/REC-SVG11-20110816/conform.html#ConformingSVGDocuments[Conforming SVG Documents]
+| `svg11.document.css2` | `style` attributes and `style` elements parse under the CSS 2 core grammar (syntax only) | https://www.w3.org/TR/2008/REC-CSS2-20080411/grammar.html[CSS 2 grammar]
+| `svg11.document.xml_stylesheet` | `xml-stylesheet` processing instructions have valid pseudo-attributes, an `href`, and a CSS `type` | https://www.w3.org/TR/1999/REC-xml-stylesheet-19990629/[xml-stylesheet]
+| `svg11.processing.script` | No `script` element or script event-handler attribute | https://www.w3.org/TR/2011/REC-SVG11-20110816/conform.html#ConformingSVGViewers[Conforming SVG Viewers]
+| `svg11.processing.animation` | No animation element or animation-timing attribute | same
+| `svg11.processing.interaction` | No interaction-only event attribute, `cursor` element or `cursor` attribute | same
+|===
+
+**Example**:
+
+[source,shell]
+----
+svg_conform check drawing.svg --profile svg_1_1_full_static --format json
+----
+
+**Behavior notes**:
+
+* Validation is offline: the DTD is resolved from the gem, and any external entity declaration is an error. No file is read and no network request is made.
+* DOM and SAX validation give the same result for the same input. A malformed document cannot be loaded as a DOM, so DOM mode raises `SvgConform::ParseError` where SAX reports `svg11.document.xml`.
+* Declaration, doctype and processing-instruction checks need the original text. A document validated from an already-parsed node (re-serialized source) is reported under `svg11.document.xml` because those claims cannot be proved.
+
+**Non-goals**: SVG Tiny or Basic, rendering or browser behavior, CSS property and value semantics, external style sheets referenced by `xml-stylesheet`, and remediation (the profile has none).
 
 [[svg-1-2-rfc-profile]]
 === SVG 1.2 RFC profile (`:svg_1_2_rfc`)
@@ -184,6 +223,51 @@ remediations:
 
 See link:remediation.adoc#viewbox-remediation[ViewboxRemediation] and link:remediation.adoc#namespace-remediation[NamespaceRemediation] for detailed remediation information.
 
+[[svg-2-secure-static-profile]]
+=== SVG 2 secure-static profile (`:svg_2_secure_static`)
+
+**Purpose**: Checks the resource and processing rules of the secure-static processing mode in the SVG 2 Candidate Recommendation of 6 October 2026 (`https://www.w3.org/TR/2026/CR-SVG2-20261006/conform.html#secure-static-mode`).
+
+The profile is opt-in. No existing profile and no default selection changes.
+
+**Stable requirement IDs** (all cite the dated secure-static section):
+
+[cols="1,3"]
+|===
+|ID |Rule
+
+|`svg2.secure_static.script` |Rejects `script` elements and script event-handler attributes.
+|`svg2.secure_static.animation` |Rejects SVG animation elements and timing attributes, and CSS `animation*` / `transition*` attributes.
+|`svg2.secure_static.interaction` |Rejects interaction event attributes and the `cursor` attribute or element.
+|`svg2.secure_static.external_reference` |Rejects references that need another document, a local file or the network.
+|===
+
+The first three IDs configure the shared `ProcessingFeaturesRequirement`; the fourth is `ExternalReferencesRequirement`, which classifies every reference with `SvgConform::References::ReferenceClassifier`.
+
+**Accepted references**:
+
+[cols="2,1,3"]
+|===
+|Reference |Result |Notes
+
+|`#fragment` in the current document |allowed |`link_validation` still reports a missing target.
+|`data:image/png` or `data:image/jpeg`, base64 or percent-encoded |allowed |Payload must be non-empty and a structurally valid PNG (chunk checksums) or JPEG (SOI/EOI).
+|`data:image/svg+xml`, base64 or percent-encoded |allowed |Must decode to one well-formed SVG document with no external reference of its own; nesting is limited to 3 levels.
+|Other media types, malformed base64 or percent-encoding |rejected |
+|`http:`, `https:`, `//host/...`, `urn:`, `file:` and other schemes |rejected |
+|Relative paths, including `other.svg#id` |rejected |
+|===
+
+Inspected locations: `href` and `xlink:href`; `fill`, `stroke`, `filter`, `clip-path`, `mask`, `marker-*` and `cursor` attributes; CSS `url(...)` and `@import` in `style` attributes and `style` elements; and `xml-stylesheet` processing instructions in the original source.
+
+**Non-goals**: This profile does not claim complete SVG 2 document, rendering or CSS conformance. It does not check `font-face` sources, CSS `@font-face`, script or animation expressed only inside CSS rules, or the contents of raster images.
+
+**Example**:
+[source,sh]
+----
+svg_conform check drawing.svg --profile svg_2_secure_static
+----
+
 [[no-external-css-profile]]
 === No external CSS profile (`:no_external_css`)
 
@@ -274,6 +358,15 @@ See link:remediation.adoc#namespace-attribute-remediation[NamespaceAttributeReme
 * **Structural compliance**: Proper namespaces and viewBox required
 * **No external dependencies**: External CSS and fonts strictly prohibited
 
+**PlantUML attributes**:
+
+The Metanorma compatibility profile accepts `contentStyleType` and `zoomAndPan`
+on `svg`, `textLength` and `lengthAdjust` on `text`, and `title` on `a`.
+These explicit allowances preserve generated diagrams' measured text layout and
+link titles. They do not change the strict RFC 7996 profiles or permit arbitrary
+additional attributes. Fragment links into a surrounding document must also be
+validated by that document's build.
+
 **Event Handler Support**:
 
 The metanorma profile allows SVG event handler attributes (e.g., `onmouseover`, `onmouseout`, `onfocus`, `onblur`) for interactive elements. This is configured using wildcard attribute patterns:

data/lib/svg_conform/cli.rb

@@ -45,9 +45,9 @@ module SvgConform
       - Directory: Requires --output-dir or --in-place
 
       REPORT FORMATS:
-      - table: Human-readable (default for single file)
-      - json: JSON format using lutaml-model
-      - yaml: YAML format using lutaml-model
+      - table: Human-readable text (default for single file; alias for the LensCore human renderer)
+      - json: LensCore diagnostics JSON (schema version 1)
+      - yaml: LensCore diagnostics YAML (schema version 1)
 
       EXAMPLES:
         svg_conform check file.svg -p metanorma

data/lib/svg_conform/commands/check.rb

@@ -69,78 +69,29 @@ module SvgConform
         result = validator.validate_file(@file,
                                          profile: @options[:profile].to_sym)
 
-        # Generate report
-        report = SvgConform::ConformanceReport.from_svg_conform_result(
-          File.basename(@file),
-          result,
-          profile: @options[:profile].to_sym,
+        # One canonical report; every output format renders from it.
+        report = SvgConform::Diagnostics::LensCoreAdapter.call(
+          result, filename: File.basename(@file)
         )
 
-        # Output based on format
-        case @options[:format]
-        when "yaml"
-          output_yaml(report)
-        when "json"
-          output_json(report)
-        else
-          output_table(report)
-        end
+        write_output(render(report))
 
         # Create remediated file if requested
         create_remediated_file(result) if @options[:fix]
 
         # Exit with appropriate code based on validation result
-        exit(report.valid? ? 0 : 1)
+        exit(report.valid ? 0 : 1)
       end
 
-      def output_table(report)
-        puts Paint["SVG Validation Report", :bold]
-        puts "=" * 50
-        puts "File: #{@file}"
-        puts "Profile: #{@options[:profile]}"
-        puts "Valid: #{report.valid? ? Paint['✓', :green] : Paint['✗', :red]}"
-        puts "Total Errors: #{report.errors.total_count}"
-        puts
-
-        if report.errors.total_count.positive?
-          puts Paint["Validation Errors:", :bold]
-          puts
-
-          # Group errors by type
-          error_groups = report.errors.issues.group_by(&:message)
-
-          error_groups.each do |message, errors|
-            puts Paint["• #{message}", :red]
-            if errors.size > 1
-              puts Paint["  (#{errors.size} occurrences)",
-                         :black]
-            end
-
-            # Show first few locations
-            errors.first(3).each do |error|
-              puts Paint["    at #{error.element}", :black] if error.element
-            end
-
-            if errors.size > 3
-              puts Paint["    ... and #{errors.size - 3} more",
-                         :black]
-            end
-            puts
-          end
-        else
-          puts Paint["✓ No validation errors found", :green]
+      # "table" stays an accepted alias for the human renderer.
+      def render(report)
+        case @options[:format]
+        when "yaml" then LensCore::Renderers::Yaml.render(report)
+        when "json" then LensCore::Renderers::Json.render(report)
+        else LensCore::Renderers::Human.render(report)
         end
       end
 
-      def output_yaml(report)
-        output = report.to_yaml
-        write_output(output)
-      end
-
-      def output_json(report)
-        write_output(report.to_json)
-      end
-
       def write_output(content)
         if @options[:output]
           File.write(@options[:output], content)

data/lib/svg_conform/conformance_report.rb

@@ -74,13 +74,20 @@ module SvgConform
     # Create report from SvgConform ValidationResult
     def self.from_svg_conform_result(filename, validation_result, profile: nil,
 use_svgcheck_mapping: false)
+      # The canonical LensCore report is built first, for every path; the
+      # legacy shape below is a deprecated projection of it. Without the
+      # optional lens_core gem the report projects the validation result
+      # directly.
+      canonical = if SvgConform.lens_core_available?
+                    validation_result.to_lens_core_report
+                  end
       report = new
       report.filename = filename
       report.profile = profile
       report.tool = "svg_conform"
       report.version = SvgConform::VERSION
       report.timestamp = Time.now.iso8601
-      report.valid = validation_result.valid?
+      report.valid = canonical ? canonical.valid : validation_result.valid?
       report.errors = IssueSummary.new
       report.errors.total_count = 0
       report.errors.by_requirement = {}
@@ -104,6 +111,15 @@ use_svgcheck_mapping: false)
         end
       end
 
+      unless use_svgcheck_mapping
+        if canonical
+          project_canonical(report, canonical)
+        else
+          project_validation_result(report, validation_result)
+        end
+        return report
+      end
+
       # Process errors (including conditional validity_errors for svgcheck compatibility)
       all_errors = validation_result.errors.dup
 
@@ -180,6 +196,68 @@ use_svgcheck_mapping: false)
       report
     end
 
+    # Fills the legacy summaries from the canonical report's error and
+    # warning diagnostics (infos have no legacy channel).
+    def self.project_canonical(report, canonical)
+      {
+        "error" => report.errors, "warning" => report.warnings
+      }.each do |severity, summary|
+        diagnostics = canonical.diagnostics.select do |d|
+          d.severity == severity
+        end
+        summary.total_count = diagnostics.length
+        diagnostics.group_by(&:requirement_id).each do |id, list|
+          summary.by_requirement[id] = list.length
+        end
+        summary.issues = diagnostics.map { |d| issue_from(d) }
+      end
+    end
+
+    def self.issue_from(diagnostic)
+      data = diagnostic.context["data"]
+      data = {} unless data.is_a?(Hash)
+      issue = ConformanceIssue.new
+      issue.type = diagnostic.severity
+      issue.requirement_id = diagnostic.requirement_id
+      issue.message = diagnostic.message
+      issue.element = diagnostic.context["element"]
+      if diagnostic.severity == "error"
+        issue.attribute = data["attribute"]
+        issue.value = data["value"]&.to_s
+      end
+      issue.line = diagnostic.location&.line
+      issue
+    end
+
+    # The lens_core-free projection: fill the summaries straight from the
+    # validation result, mirroring project_canonical's output shape.
+    def self.project_validation_result(report, result)
+      {
+        "error" => [report.errors, result.errors],
+        "warning" => [report.warnings, result.warnings],
+      }.each do |severity, (summary, issues)|
+        summary.total_count = issues.length
+        issues.group_by(&:requirement_id).each do |id, list|
+          summary.by_requirement[id] = list.length
+        end
+        summary.issues = issues.map do |error|
+          issue = ConformanceIssue.new
+          issue.type = severity
+          issue.requirement_id = error.requirement_id
+          issue.message = error.message
+          issue.element = error.element_name
+          if severity == "error"
+            issue.attribute = error.data[:attribute] if error.respond_to?(:data) && error.data
+            issue.value = error.data[:value]&.to_s if error.respond_to?(:data) && error.data
+          end
+          issue.line = error.line if error.respond_to?(:line)
+          issue
+        end
+      end
+    end
+    private_class_method :project_canonical, :issue_from,
+                         :project_validation_result
+
     # Create report from svgcheck error output
     def self.from_svgcheck_result(filename, error_content,
 _output_content = nil)