facturx 1.1.0 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 61ff49d55f56bb55d9b6624eb58fd59e16ed016672464f72507ea21b556c3050
-  data.tar.gz: 3f6be26b5cb8a65ea5d024cc68c709835154cd67fd48147d4a184182f7938c19
+  metadata.gz: 8beb5aea7a14256c4d062dfbf732462016ec2e0eaacafedf016235f085353eee
+  data.tar.gz: 24ea8be809ed5b980cb01b2dee2a775c76c21ae717dda9c056182880bfc44e3d
 SHA512:
-  metadata.gz: 071dce1b5bb8ca3925152e2c0b5bcebaff0b2d73399d7e681f9407eeb59bb0ba981dbcbc194cb9b8faace203cdddc7ba5b332c22e92b377b3082d2641dacce8b
-  data.tar.gz: 1ffab4f27f2f0ba54e6ffcf3e5d949aafecde9dd92c758acb1f3a1c9f4a1792794b2c91372d564ec49c917114c715f061d90843a14393fabac44bb0058af03c7
+  metadata.gz: 93279c7e5faaebe8aa8d2b4c645f739e6a70517fa530340186621af496b95e3ec29b5f84a99fcb6edfadb0601013e0b945d3aaf2440eb02aa30c395eb06f5f6e
+  data.tar.gz: 04af7d886516bebfa086252a99892721b9a9a775271e35abc94641ac40fbfbb70865be020cf93b41123c317ae794d823ec7ce0104119f0a7cdb8829d6ac3ba64

data/CHANGELOG.md

@@ -4,6 +4,20 @@ All notable changes to this project will be documented in this file.
 
 ## [Unreleased]
 
+## [1.2.0] - 2026-09-14
+
+### Add
+
+- Add optional official Schematron validation through the lightweight `facturx-schematron` companion gem.
+- Add Schematron issues and strict errors to the existing validation model for all writing and attachment workflows.
+- Add shared bounded subprocess execution for Ghostscript and SaxonC without loading optional rules in the core gem.
+
+### Fix
+
+- Preserve non-UTF-8 invoice text when passing parsed XML to SaxonC.
+- Report oversized Schematron output as a resource limit instead of malformed validation output.
+- Keep subprocess timeout diagnostics valid UTF-8 while preserving raw successful output bytes.
+
 ## [1.1.0] - 2026-09-14
 
 ### Add
@@ -58,7 +72,8 @@ All notable changes to this project will be documented in this file.
 - Compose PDF/A-3b Factur-X documents with Ghostscript.
 - Extract embedded Factur-X XML from PDF documents.
 
-[Unreleased]: https://github.com/AdVitam/facturx/compare/v1.1.0...HEAD
+[Unreleased]: https://github.com/AdVitam/facturx/compare/v1.2.0...HEAD
+[1.2.0]: https://github.com/AdVitam/facturx/compare/v1.1.0...v1.2.0
 [1.1.0]: https://github.com/AdVitam/facturx/compare/v1.0.0...v1.1.0
 [1.0.0]: https://github.com/AdVitam/facturx/compare/v0.2.0...v1.0.0
 [0.2.0]: https://github.com/AdVitam/facturx/compare/v0.1.0...v0.2.0

data/DOCUMENTATION.md

@@ -193,14 +193,44 @@ report.issues.each do |issue|
 end
 ```
 
-All issues currently emitted use the `:error` severity. The `:warning` severity is reserved for planned Schematron diagnostics.
+Core validation issues use the `:error` severity. The optional Schematron validator also preserves official `:warning` findings, which do not invalidate a report.
 
-Generated documents pass through two layers:
+Generated documents always pass through two layers:
 
 1. semantic conformance checks against the selected profile's business-term cardinalities and supported model mappings;
 2. structural validation against the bundled official profile XSD.
 
-Incoming XML passed to `validate_xml` is parsed, resolved to a profile from BT-24, and checked against that profile's XSD.
+Incoming XML passed to `validate_xml` is parsed, resolved to a profile from BT-24, and checked against that profile's XSD. When enabled, Schematron runs after these core checks as a third validation layer.
+
+### Optional Schematron validation
+
+Install the companion gem to add the official Factur-X 1.09.2 business rules without increasing the core gem's package or runtime footprint:
+
+```ruby
+gem 'facturx'
+gem 'facturx-schematron', require: 'facturx/schematron'
+```
+
+Alternatively, require it explicitly after Bundler setup:
+
+```ruby
+require 'facturx'
+require 'facturx/schematron'
+```
+
+Loading the companion enables Schematron after XSD validation for `validate_xml`, `validate_document`, `attach`, `build_xml`, and `generate`. Public method signatures and report types remain unchanged. `read` stays tolerant and does not validate implicitly.
+
+The companion requires SaxonC-HE's `Transform` executable, version 12.10 or newer. Put it in `PATH`, or provide its absolute path:
+
+```bash
+export FACTURX_SAXONC_TRANSFORM=/opt/saxonc/bin/Transform
+```
+
+Loading fails immediately with `Facturx::Schematron::UnavailableError` when the executable is missing, cannot start, or is unsupported. Runtime engine failures raise `Facturx::Schematron::ExecutionError`; they never fall back silently to XSD-only validation.
+
+Schematron findings use the `:schematron` layer and expose the official rule ID, test, and flag in `issue.details`. Official warnings keep reports valid; assertions without a warning flag are errors. Strict XML workflows raise `Facturx::SchematronValidationError` for blocking findings.
+
+The companion ships only the five official compiled XSLT stylesheets and adjacent code databases. Each successful validation starts one isolated SaxonC subprocess, so applications processing large batches should account for native process startup and memory in their worker sizing.
 
 Domain failures use a `Facturx::Error` subclass with structured context in `details`. Common errors include:
 
@@ -210,6 +240,7 @@ Domain failures use a `Facturx::Error` subclass with structured context in `deta
 | `Facturx::InvalidXmlError` | XML cannot be parsed |
 | `Facturx::UnknownProfileError` | BT-24 is absent or unsupported during strict XML validation |
 | `Facturx::XsdValidationError` | XML does not satisfy the selected profile XSD |
+| `Facturx::SchematronValidationError` | XML violates an enabled Schematron business rule |
 | `Facturx::UnsupportedProfileError` | A writer profile is unsupported |
 | `Facturx::InvalidDocumentError` | A typed document violates the selected profile |
 | `Facturx::InvalidSourceError` | An XML or reader source is not a byte `String` |
@@ -220,7 +251,7 @@ Domain failures use a `Facturx::Error` subclass with structured context in `deta
 | `Facturx::ExtractionError` | The embedded Factur-X XML cannot be selected or decoded |
 | `Facturx::VerificationError` | The composed PDF does not match the requested invoice |
 
-XSD validation is not complete regulatory validation. Facturx does not yet run the official Schematron business rules, calculate totals, or evaluate accounting consistency.
+XSD validation alone is not complete regulatory validation. The optional companion runs the official Schematron rules, but Facturx does not calculate invoice values or replace application-level accounting controls.
 
 ## PDF composition
 
@@ -238,7 +269,7 @@ export FACTURX_ZUGFERD_PS=/opt/ghostscript/share/ghostscript/lib/zugferd.ps
 export FACTURX_ICC_PROFILE=/opt/ghostscript/share/ghostscript/iccprofiles/default_rgb.icc
 ```
 
-The composer invokes Ghostscript as an external process with a timeout, bounded output capture, and file access restricted to its staged inputs and outputs.
+The composer invokes Ghostscript as an external process with a timeout, bounded output capture, and file access restricted to its staged inputs and outputs. The optional Schematron integration reuses the same bounded process lifecycle for SaxonC.
 
 Facturx does not create the visual invoice. The supplied PDF remains the visual source that is converted to PDF/A-3b and enriched with Factur-X XML and metadata.
 
@@ -260,8 +291,8 @@ Facturx does not communicate with a PDP or implement e-invoicing transport. Netw
 mise install
 bundle install
 bundle exec rubocop
-bundle exec rspec
-bundle exec rake build
+bundle exec rake
+bundle exec rake build_all
 ```
 
 Maintainers can compare the semantic registry, D22B mappings, diagnostics, official XML examples, and paired PDF attachments with an extracted upstream package:

data/README.md

@@ -26,39 +26,42 @@ Use typed Ruby objects to generate XSD-valid XML, embed it into an existing PDF,
 | ✅ | Generate Factur-X XML | `Facturx.build_xml` |
 | ✅ | Validate typed documents | `Facturx.validate_document` |
 | ✅ | Validate XML against official XSDs | `Facturx.validate_xml` |
+| 🔌 | Add official Schematron business-rule validation | `facturx-schematron` |
 | ✅ | Extract the original embedded XML | `Facturx.extract_xml` |
 
 ### Boundaries
 
 | | Capability | Responsibility |
 |:---:|---|---|
-| ⏳ | Schematron business rules | Planned |
 | ➖ | Invoice calculations | Application |
 | ➖ | Visual PDF generation | Application |
 | ➖ | PDP transport and e-invoicing | Application |
 
-✅ Supported · ⏳ Planned · ➖ Intentionally handled outside the gem
+✅ Included · 🔌 Optional companion · ➖ Intentionally handled outside the gem
 
 ## Supported profiles
 
 Facturx supports Factur-X 1.09.2 / ZUGFeRD 2.5.2.
 
-| Profile | Read | Build | XSD validation |
-|---|:---:|:---:|:---:|
-| MINIMUM | ✅ | ✅ | ✅ |
-| BASIC WL | ✅ | ✅ | ✅ |
-| BASIC | ✅ | ✅ | ✅ |
-| EN 16931 | ✅ | ✅ | ✅ |
-| EXTENDED | ✅* | ✅* | ✅ |
+| Profile | Read | Build | XSD | Schematron** |
+|---|:---:|:---:|:---:|:---:|
+| MINIMUM | ✅ | ✅ | ✅ | ✅ |
+| BASIC WL | ✅ | ✅ | ✅ | ✅ |
+| BASIC | ✅ | ✅ | ✅ | ✅ |
+| EN 16931 | ✅ | ✅ | ✅ | ✅ |
+| EXTENDED | ✅* | ✅* | ✅ | ✅ |
 
 \* EXTENDED-only fields that are not represented by the typed model remain available in the original XML and are reported through diagnostics.
 
+\** Available through the optional `facturx-schematron` gem.
+
 ## Requirements
 
 - Ruby 3.2 or newer
 - Ghostscript 9.54 or newer, `zugferd.ps`, and an RGB ICC profile for PDF composition only
+- SaxonC-HE 12.10 or newer only when `facturx-schematron` is enabled
 
-XML building, reading, extraction, and validation require no external executable.
+Core XML building, reading, extraction, and XSD validation require no external executable.
 
 ## Quick start
 
@@ -104,6 +107,7 @@ See [DOCUMENTATION.md](DOCUMENTATION.md) to:
 - validate or attach existing XML;
 - read invoices and handle diagnostics;
 - understand profiles, validation boundaries, and typed errors;
+- enable official Schematron business-rule validation;
 - configure Ghostscript for PDF/A-3b composition.
 
 ## License

data/lib/facturx/composers/ghostscript/runner.rb

@@ -1,74 +1,31 @@
 # frozen_string_literal: true
 
-require 'open3'
-require 'timeout'
 require_relative '../../error'
-require_relative 'output_capture'
+require_relative '../../subprocess'
 
 module Facturx
   module Composers
     class Ghostscript
       class Runner
-        Result = Data.define(:stdout, :stderr, :exit_status)
-
-        DEFAULT_TIMEOUT = 60
-        DEFAULT_OUTPUT_LIMIT = 8_192
-        DEFAULT_TERMINATION_GRACE = 1
         def initialize(
-          timeout: DEFAULT_TIMEOUT,
-          output_limit: DEFAULT_OUTPUT_LIMIT,
-          termination_grace: DEFAULT_TERMINATION_GRACE
+          timeout: Subprocess::Runner::DEFAULT_TIMEOUT,
+          output_limit: Subprocess::Runner::DEFAULT_OUTPUT_LIMIT,
+          termination_grace: Subprocess::Runner::DEFAULT_TERMINATION_GRACE
         )
-          @timeout = timeout
-          @output_limit = output_limit
-          @termination_grace = termination_grace
+          @runner = Subprocess::Runner.new(timeout:, output_limit:, termination_grace:)
         end
 
         def call(argv)
-          result = execute(argv)
+          result = @runner.call(argv)
           return result if result.exit_status.zero?
 
           raise_failed(result)
-        rescue CompositionError
-          raise
-        rescue SystemCallError => e
-          raise CompositionError.new(
-            "Ghostscript could not be executed: #{e.message}",
-            cause: e.class.name
-          )
+        rescue Subprocess::Error => e
+          raise_process_error(e)
         end
 
         private
 
-        def execute(argv)
-          Open3.popen3(*argv, pgroup: true) do |stdin, stdout, stderr, wait_thread|
-            capture_process(stdin, stdout, stderr, wait_thread)
-          end
-        end
-
-        def capture_process(stdin, stdout, stderr, wait_thread)
-          stdin.close
-          stdout_reader = capture(stdout)
-          stderr_reader = capture(stderr)
-          build_result(wait_thread, stdout_reader, stderr_reader)
-        ensure
-          stdout_reader&.join
-          stderr_reader&.join
-        end
-
-        def build_result(wait_thread, stdout_reader, stderr_reader)
-          status = wait_for(wait_thread, stderr_reader)
-          Result.new(
-            stdout: stdout_reader.value,
-            stderr: stderr_reader.value,
-            exit_status: exit_status(status)
-          )
-        end
-
-        def exit_status(status)
-          status.exitstatus || (128 + status.termsig)
-        end
-
         def raise_failed(result)
           raise CompositionError.new(
             "Ghostscript failed with exit status #{result.exit_status}",
@@ -78,39 +35,21 @@ module Facturx
           )
         end
 
-        def wait_for(wait_thread, stderr_reader)
-          Timeout.timeout(@timeout) { wait_thread.value }
-        rescue Timeout::Error
-          terminate(wait_thread)
+        def raise_process_error(error)
+          return raise_timeout(error) if error.details[:reason] == :timeout
+
           raise CompositionError.new(
-            "Ghostscript timed out after #{@timeout} seconds",
-            timeout: @timeout,
-            stderr: sanitize(stderr_reader.value)
+            "Ghostscript could not be executed: #{error.details[:message]}",
+            cause: error.details[:cause]
           )
         end
 
-        def capture(stream)
-          Thread.new { OutputCapture.new(stream, limit: @output_limit).call }
-        end
-
-        def terminate(wait_thread)
-          signal('TERM', wait_thread.pid)
-          return if wait_thread.join(@termination_grace)
-
-          signal('KILL', wait_thread.pid)
-          wait_thread.join
-        end
-
-        def signal(name, pid)
-          Process.kill(name, -pid)
-        rescue Errno::ESRCH
-          nil
-        rescue SystemCallError
-          begin
-            Process.kill(name, pid)
-          rescue Errno::ESRCH
-            nil
-          end
+        def raise_timeout(error)
+          raise CompositionError.new(
+            "Ghostscript timed out after #{error.details[:timeout]} seconds",
+            timeout: error.details[:timeout],
+            stderr: sanitize(error.details[:stderr])
+          )
         end
 
         def sanitize(output)

data/lib/facturx/error.rb

@@ -15,6 +15,7 @@ module Facturx
   class InvalidXmlError < ValidationError; end
   class UnknownProfileError < InvalidXmlError; end
   class XsdValidationError < InvalidXmlError; end
+  class SchematronValidationError < InvalidXmlError; end
   class SchemaLoadError < Error; end
   class InvalidSourceError < Error; end
   class UnsupportedProfileError < Error; end

data/lib/facturx/schematron_adapter.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Facturx
+  module SchematronAdapter
+    class NullValidator
+      def call(**)
+        []
+      end
+    end
+
+    @mutex = Mutex.new
+    @validator = NullValidator.new.freeze
+
+    class << self
+      def install(validator)
+        raise TypeError, 'Schematron validator must respond to call' unless validator.respond_to?(:call)
+
+        @mutex.synchronize { @validator = validator }
+      end
+
+      def call(document:, profile:)
+        @validator.call(document:, profile:)
+      end
+    end
+
+    private_constant :NullValidator
+  end
+
+  private_constant :SchematronAdapter
+end

data/lib/facturx/subprocess.rb

@@ -0,0 +1,154 @@
+# frozen_string_literal: true
+
+require 'open3'
+require 'timeout'
+require_relative 'error'
+
+module Facturx
+  module Subprocess
+    Result = Data.define(:stdout, :stderr, :exit_status, :stdout_truncated)
+
+    class Error < Facturx::Error; end
+
+    class OutputCapture
+      TRUNCATION_MARKER = '...[truncated]'
+      Output = Data.define(:content, :truncated)
+
+      def initialize(stream, limit:)
+        @stream = stream
+        @limit = limit
+      end
+
+      def call
+        buffer = +''.b
+        truncated = false
+        while (chunk = @stream.read(4_096))
+          remaining = @limit - buffer.bytesize
+          buffer << chunk.byteslice(0, remaining) if remaining.positive?
+          truncated ||= chunk.bytesize > remaining
+        end
+        Output.new(content: truncate(buffer, truncated), truncated:)
+      rescue IOError
+        Output.new(content: buffer, truncated:)
+      end
+
+      private
+
+      def truncate(buffer, truncated)
+        return buffer unless truncated
+
+        marker = TRUNCATION_MARKER.byteslice(0, @limit)
+        kept_bytes = [@limit - marker.bytesize, 0].max
+        buffer.byteslice(0, kept_bytes).to_s << marker
+      end
+    end
+
+    class Runner
+      DEFAULT_TIMEOUT = 60
+      DEFAULT_OUTPUT_LIMIT = 8_192
+      DEFAULT_TERMINATION_GRACE = 1
+
+      def initialize(
+        timeout: DEFAULT_TIMEOUT,
+        output_limit: DEFAULT_OUTPUT_LIMIT,
+        termination_grace: DEFAULT_TERMINATION_GRACE
+      )
+        @timeout = timeout
+        @output_limit = output_limit
+        @termination_grace = termination_grace
+      end
+
+      def call(argv, input: nil, chdir: nil)
+        execute(argv, input:, chdir:)
+      rescue SystemCallError => e
+        raise Error.new('Process could not be executed', reason: :spawn, cause: e.class.name, message: e.message)
+      end
+
+      private
+
+      def execute(argv, input:, chdir:)
+        options = { pgroup: true }
+        options[:chdir] = chdir if chdir
+        Open3.popen3(*argv, **options) do |stdin, stdout, stderr, wait_thread|
+          capture_process(stdin, stdout, stderr, wait_thread, input)
+        end
+      end
+
+      def capture_process(stdin, stdout, stderr, wait_thread, input)
+        stdin_writer = write(stdin, input)
+        stdout_reader = capture(stdout)
+        stderr_reader = capture(stderr)
+        build_result(wait_thread, stdout_reader, stderr_reader)
+      ensure
+        stdin_writer&.join
+        stdout_reader&.join
+        stderr_reader&.join
+      end
+
+      def write(stdin, input)
+        Thread.new do
+          stdin.binmode
+          stdin.write(input) if input
+        rescue Errno::EPIPE, IOError
+          nil
+        ensure
+          stdin.close
+        end
+      end
+
+      def capture(stream)
+        Thread.new { OutputCapture.new(stream, limit: @output_limit).call }
+      end
+
+      def build_result(wait_thread, stdout_reader, stderr_reader)
+        status = wait_for(wait_thread, stderr_reader)
+        stdout = stdout_reader.value
+        stderr = stderr_reader.value
+        Result.new(
+          stdout: stdout.content,
+          stderr: stderr.content,
+          exit_status: status.exitstatus || (128 + status.termsig),
+          stdout_truncated: stdout.truncated
+        )
+      end
+
+      def wait_for(wait_thread, stderr_reader)
+        Timeout.timeout(@timeout) { wait_thread.value }
+      rescue Timeout::Error
+        terminate(wait_thread)
+        raise Error.new(
+          "Process timed out after #{@timeout} seconds",
+          reason: :timeout,
+          timeout: @timeout,
+          stderr: sanitize(stderr_reader.value.content)
+        )
+      end
+
+      def terminate(wait_thread)
+        signal('TERM', wait_thread.pid)
+        return if wait_thread.join(@termination_grace)
+
+        signal('KILL', wait_thread.pid)
+        wait_thread.join
+      end
+
+      def sanitize(output)
+        output.to_s.encode(Encoding::UTF_8, invalid: :replace, undef: :replace, replace: '?')
+      end
+
+      def signal(name, pid)
+        Process.kill(name, -pid)
+      rescue Errno::ESRCH
+        nil
+      rescue SystemCallError
+        begin
+          Process.kill(name, pid)
+        rescue Errno::ESRCH
+          nil
+        end
+      end
+    end
+
+    private_constant :OutputCapture
+  end
+end

data/lib/facturx/validation.rb

@@ -5,7 +5,7 @@ require_relative 'model/immutable'
 
 module Facturx
   module Validation
-    LAYERS = %i[syntax profile document xsd].freeze
+    LAYERS = %i[syntax profile document xsd schematron].freeze
     SEVERITIES = %i[error warning].freeze
     ISSUE_DEFAULTS = {
       severity: :error,

data/lib/facturx/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Facturx
-  VERSION = '1.1.0'
+  VERSION = '1.2.0'
 end

data/lib/facturx/writer.rb

@@ -11,7 +11,7 @@ require_relative 'writer/stages/trade_lines'
 require_relative 'writer/stages/trade_agreement'
 require_relative 'writer/stages/trade_delivery'
 require_relative 'writer/stages/trade_settlement'
-require_relative 'xml/schema_validator'
+require_relative 'xml/conformance_validator'
 require_relative 'xml/report_builder'
 
 module Facturx
@@ -30,8 +30,8 @@ module Facturx
       raise 'Factur-X writer stages must cover every modeled term exactly once'
     end
 
-    def initialize(schema_validator: Xml::SchemaValidator.new)
-      @schema_validator = schema_validator
+    def initialize(conformance_validator: Xml::ConformanceValidator.new)
+      @conformance_validator = conformance_validator
     end
 
     def call(document:, profile:)
@@ -60,8 +60,8 @@ module Facturx
       report = context.tracker.report
       return report if report.invalid?
 
-      @schema_validator.call(document: context.xml, profile:)
-      report
+      issues = @conformance_validator.call(document: context.xml, profile:)
+      report.with(issues: report.issues + issues)
     rescue XsdValidationError => e
       Xml::ReportBuilder.xsd(profile, e)
     end

data/lib/facturx/xml/conformance_validator.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require_relative '../schematron_adapter'
+require_relative 'schema_validator'
+
+module Facturx
+  module Xml
+    class ConformanceValidator
+      def initialize(schema_validator: SchemaValidator.new, schematron_validator: SchematronAdapter)
+        @schema_validator = schema_validator
+        @schematron_validator = schematron_validator
+      end
+
+      def call(document:, profile:)
+        @schema_validator.call(document:, profile:)
+        @schematron_validator.call(document:, profile:)
+      end
+    end
+  end
+end

data/lib/facturx/xml/validator.rb

@@ -4,22 +4,26 @@ require_relative '../validation'
 require_relative 'parser'
 require_relative 'profile_detector'
 require_relative 'report_builder'
-require_relative 'schema_validator'
+require_relative 'conformance_validator'
 
 module Facturx
   module Xml
     class Validator
-      def initialize(parser: Parser.new, profile_detector: ProfileDetector.new, schema_validator: SchemaValidator.new)
+      def initialize(
+        parser: Parser.new,
+        profile_detector: ProfileDetector.new,
+        conformance_validator: ConformanceValidator.new
+      )
         @parser = parser
         @profile_detector = profile_detector
-        @schema_validator = schema_validator
+        @conformance_validator = conformance_validator
       end
 
       def call(xml:)
         document = @parser.call(xml:)
         profile = @profile_detector.call(document:)
-        @schema_validator.call(document:, profile:)
-        Validation::Report.new(profile:)
+        issues = @conformance_validator.call(document:, profile:)
+        Validation::Report.new(profile:, issues:)
       rescue UnknownProfileError => e
         ReportBuilder.profile(e)
       rescue XsdValidationError => e

data/lib/facturx/xml/verifier.rb

@@ -8,7 +8,8 @@ module Facturx
       ERROR_CLASSES = {
         syntax: InvalidXmlError,
         profile: UnknownProfileError,
-        xsd: XsdValidationError
+        xsd: XsdValidationError,
+        schematron: SchematronValidationError
       }.freeze
       private_constant :ERROR_CLASSES
 
@@ -20,7 +21,7 @@ module Facturx
         report = @validator.call(xml:)
         return report.profile if report.valid?
 
-        issue = report.issues.first
+        issue = report.issues.find { |candidate| candidate.severity == :error }
         error_class = ERROR_CLASSES.fetch(issue.layer)
         raise error_class.new(issue.message, report:, issues: report.issues)
       end

data/lib/facturx.rb

@@ -17,6 +17,9 @@ require 'facturx/reading'
 require 'facturx/coerce'
 require 'facturx/format'
 require 'facturx/validation'
+require 'facturx/schematron_adapter'
+require 'facturx/subprocess'
+require 'facturx/xml/conformance_validator'
 require 'facturx/xml/validator'
 require 'facturx/xml/verifier'
 require 'facturx/pdf/document'
@@ -81,5 +84,5 @@ module Facturx
 
   private_constant :Attach, :Builders, :Coerce, :CoercionError, :Composers, :Format, :FormattingError,
                    :Generate, :Group, :Model, :Pdf, :ProfileResolver, :Reader, :SourceReader, :Term,
-                   :TermDeclarations, :Terms, :Writer, :Xml
+                   :SchematronAdapter, :Subprocess, :TermDeclarations, :Terms, :Writer, :Xml
 end

data/rbi/facturx.rbi

@@ -16,6 +16,7 @@ module Facturx
   class InvalidXmlError < ValidationError; end
   class UnknownProfileError < InvalidXmlError; end
   class XsdValidationError < InvalidXmlError; end
+  class SchematronValidationError < InvalidXmlError; end
   class SchemaLoadError < Error; end
   class InvalidSourceError < Error; end
   class UnsupportedProfileError < Error; end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: facturx
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 1.2.0
 platform: ruby
 authors:
 - AdVitam
@@ -66,7 +66,6 @@ files:
 - lib/facturx/composers/ghostscript.rb
 - lib/facturx/composers/ghostscript/defaults.rb
 - lib/facturx/composers/ghostscript/locator.rb
-- lib/facturx/composers/ghostscript/output_capture.rb
 - lib/facturx/composers/ghostscript/runner.rb
 - lib/facturx/composers/ghostscript/version_probe.rb
 - lib/facturx/diagnostic.rb
@@ -130,7 +129,9 @@ files:
 - lib/facturx/schema/LICENSE-APACHE-2.0.txt
 - lib/facturx/schema/NOTICE.md
 - lib/facturx/schema/SHA256SUMS
+- lib/facturx/schematron_adapter.rb
 - lib/facturx/source_reader.rb
+- lib/facturx/subprocess.rb
 - lib/facturx/term.rb
 - lib/facturx/terms.rb
 - lib/facturx/terms/declaration.rb
@@ -172,6 +173,7 @@ files:
 - lib/facturx/writer/stages/trade_settlement/summary.rb
 - lib/facturx/writer/stages/trade_settlement/taxes.rb
 - lib/facturx/writer/tracker.rb
+- lib/facturx/xml/conformance_validator.rb
 - lib/facturx/xml/namespaces.rb
 - lib/facturx/xml/parser.rb
 - lib/facturx/xml/profile_detector.rb

data/lib/facturx/composers/ghostscript/output_capture.rb

@@ -1,39 +0,0 @@
-# frozen_string_literal: true
-
-module Facturx
-  module Composers
-    class Ghostscript
-      class OutputCapture
-        TRUNCATION_MARKER = '...[truncated]'
-
-        def initialize(stream, limit:)
-          @stream = stream
-          @limit = limit
-        end
-
-        def call
-          buffer = +''.b
-          truncated = false
-          while (chunk = @stream.read(4_096))
-            remaining = @limit - buffer.bytesize
-            buffer << chunk.byteslice(0, remaining) if remaining.positive?
-            truncated ||= chunk.bytesize > remaining
-          end
-          truncate(buffer, truncated)
-        rescue IOError
-          buffer
-        end
-
-        private
-
-        def truncate(buffer, truncated)
-          return buffer unless truncated
-
-          marker = TRUNCATION_MARKER.byteslice(0, @limit)
-          kept_bytes = [@limit - marker.bytesize, 0].max
-          buffer.byteslice(0, kept_bytes).to_s << marker
-        end
-      end
-    end
-  end
-end