facturx 1.0.0 → 1.2.0

data/lib/facturx/{conformance.rb → writer/tracker.rb}

@@ -1,38 +1,69 @@
 # frozen_string_literal: true
 
-require_relative 'error'
-require_relative 'model/immutable'
+require_relative '../error'
+require_relative '../validation'
 
 module Facturx
-  module Conformance
-    Issue = Data.define(:code, :message, :term_id, :group_id, :path, :details) do
-      include Model::ValidatedWith
+  class Writer
+    class Tracker
+      attr_reader :profile
+
+      def initialize(profile:)
+        @profile = profile
+        @issues = []
+      end
 
-      def initialize(**attributes)
-        Model.validate_attributes!(self.class.members, attributes)
-        attributes.fetch_values(:code, :message)
-        values = { term_id: nil, group_id: nil, path: nil, details: {} }.merge(attributes)
-        raise TypeError, 'details must be a Hash' unless values[:details].is_a?(Hash)
+      def check_guideline(guideline_urn, path: nil)
+        return if guideline_urn.nil? || guideline_urn == profile.guideline_urn
 
-        super(**values.transform_values { |value| Model.copy_and_freeze(value) })
+        add(
+          :profile_mismatch,
+          'Document guideline does not match the selected profile',
+          term_id: 'BT-24',
+          path:,
+          details: { expected: profile.guideline_urn, actual: guideline_urn }
+        )
       end
-    end
 
-    Report = Data.define(:profile, :issues) do
-      include Model::ValidatedWith
+      def check_document(document, path: nil)
+        check_guideline(document.guideline_urn, path:)
+      end
 
-      def initialize(profile:, issues: [])
-        raise TypeError, 'issues must be an Array' unless issues.is_a?(Array)
+      def observe_group?(group, count:, path: nil)
+        definition_observed?(group, count, path)
+      end
 
-        super(profile: Model.copy_and_freeze(profile), issues: Model.copy_and_freeze(issues))
+      def observe_term?(term, values:, path: nil)
+        definition_observed?(term, values.size, path)
       end
 
-      def valid? = issues.empty?
+      def invalid_term(term, error:, path: nil)
+        raise TypeError, 'error must be a FormattingError' unless error.is_a?(FormattingError)
 
-      def invalid? = !valid?
-    end
+        add(
+          :invalid_value,
+          error.message,
+          term_id: term.id,
+          group_id: term.group_id,
+          path: path || error.details[:path] || term.xpath,
+          details: error.details
+        )
+      end
+
+      def unrepresentable_attribute(group, model:, attribute:, path: nil)
+        add(
+          :unrepresentable_attribute,
+          'Model attribute cannot be represented in this group',
+          group_id: group.id,
+          path: path || group.xpath,
+          details: { model:, attribute: }
+        )
+      end
+
+      def report
+        Validation::Report.new(profile:, issues: @issues)
+      end
 
-    module Tracking
       private
 
       def definition_observed?(definition, count, path)
@@ -77,7 +108,7 @@ module Facturx
       end
 
       def add(code, message, **context)
-        @issues << Issue.new(code:, message:, **context)
+        @issues << Validation::Issue.new(code:, message:, layer: :document, **context)
       end
 
       def definition_context(definition, path)
@@ -96,68 +127,5 @@ module Facturx
 
       def repeated?(cardinality) = cardinality.end_with?('n')
     end
-    private_constant :Tracking
-
-    class Tracker
-      include Tracking
-
-      attr_reader :profile
-
-      def initialize(profile:)
-        @profile = profile
-        @issues = []
-      end
-
-      def check_guideline(guideline_urn, path: nil)
-        return if guideline_urn.nil? || guideline_urn == profile.guideline_urn
-
-        add(
-          :profile_mismatch,
-          'Document guideline does not match the selected profile',
-          term_id: 'BT-24',
-          path:,
-          details: { expected: profile.guideline_urn, actual: guideline_urn }
-        )
-      end
-
-      def check_document(document, path: nil)
-        check_guideline(document.guideline_urn, path:)
-      end
-
-      def observe_group?(group, count:, path: nil)
-        definition_observed?(group, count, path)
-      end
-
-      def observe_term?(term, values:, path: nil)
-        definition_observed?(term, values.size, path)
-      end
-
-      def invalid_term(term, error:, path: nil)
-        raise TypeError, 'error must be a FormattingError' unless error.is_a?(FormattingError)
-
-        add(
-          :invalid_value,
-          error.message,
-          term_id: term.id,
-          group_id: term.group_id,
-          path: path || error.details[:path] || term.xpath,
-          details: error.details
-        )
-      end
-
-      def unrepresentable_attribute(group, model:, attribute:, path: nil)
-        add(
-          :unrepresentable_attribute,
-          'Model attribute cannot be represented in this group',
-          group_id: group.id,
-          path: path || group.xpath,
-          details: { model:, attribute: }
-        )
-      end
-
-      def report
-        Report.new(profile:, issues: @issues)
-      end
-    end
   end
 end

data/lib/facturx/writer.rb

@@ -1,17 +1,18 @@
 # frozen_string_literal: true
 
-require_relative 'conformance'
 require_relative 'error'
 require_relative 'terms'
 require_relative 'writer/context'
 require_relative 'writer/stage'
+require_relative 'writer/tracker'
 require_relative 'writer/stages/document_context'
 require_relative 'writer/stages/exchanged_document'
 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
   class Writer
@@ -29,37 +30,44 @@ module Facturx
       raise 'Factur-X writer stages must cover every modeled term exactly once'
     end
 
-    def initialize(schema_validator: Xml::SchemaValidator.new, tracker: Conformance::Tracker, stages: STAGES)
-      @schema_validator = schema_validator
-      @tracker_class = tracker
-      @stages = stages.freeze
+    def initialize(conformance_validator: Xml::ConformanceValidator.new)
+      @conformance_validator = conformance_validator
     end
 
     def call(document:, profile:)
       context = compile(document:, profile:)
-      report = context.tracker.report
-      raise_conformance_error(profile, report) if report.invalid?
+      report = validate_context(context, profile)
+      raise_invalid_document(profile, report) if report.invalid?
 
-      @schema_validator.call(document: context.xml, profile:)
       context.to_xml
     end
 
     def validate(document:, profile:)
-      compile(document:, profile:).tracker.report
+      validate_context(compile(document:, profile:), profile)
     end
 
     private
 
     def compile(document:, profile:)
-      tracker = @tracker_class.new(profile:)
+      tracker = Tracker.new(profile:)
       tracker.check_document(document, path: Terms.fetch('BT-24').xpath)
       context = Context.new(document:, profile:, tracker:)
-      @stages.each { |stage| stage.new(context).call }
+      STAGES.each { |stage| stage.new(context).call }
       context
     end
 
-    def raise_conformance_error(profile, report)
-      raise ConformanceError.new(
+    def validate_context(context, profile)
+      report = context.tracker.report
+      return report if report.invalid?
+
+      issues = @conformance_validator.call(document: context.xml, profile:)
+      report.with(issues: report.issues + issues)
+    rescue XsdValidationError => e
+      Xml::ReportBuilder.xsd(profile, e)
+    end
+
+    def raise_invalid_document(profile, report)
+      raise InvalidDocumentError.new(
         'Factur-X document does not conform to the selected profile',
         profile: profile.id, report:, issues: report.issues
       )

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/parser.rb

@@ -8,7 +8,7 @@ module Facturx
     class Parser
       def call(xml:)
         unless xml.is_a?(String)
-          raise InvalidXmlError.new('XML must be provided as a byte String', input_class: xml.class.name)
+          raise InvalidSourceError.new('XML must be provided as a byte String', input_class: xml.class.name)
         end
 
         Nokogiri::XML::Document.parse(xml) { |config| config.strict.nonet }

data/lib/facturx/xml/report_builder.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require_relative '../validation'
+
+module Facturx
+  module Xml
+    class ReportBuilder
+      class << self
+        def syntax(error)
+          from_error(error, layer: :syntax, code: :invalid_xml)
+        end
+
+        def profile(error)
+          guideline_urn = error.details[:guideline_urn]
+          code = guideline_urn.nil? || guideline_urn.empty? ? :missing_profile : :unknown_profile
+          from_error(error, layer: :profile, code:)
+        end
+
+        def xsd(profile, error)
+          from_error(error, profile:, layer: :xsd, code: :xsd_violation)
+        end
+
+        private
+
+        def from_error(error, layer:, code:, profile: nil)
+          diagnostics = error.details[:errors] || [{ message: error.message }]
+          issues = diagnostics.map { |diagnostic| issue(error, diagnostic, layer:, code:) }
+          Validation::Report.new(profile:, issues:)
+        end
+
+        def issue(error, diagnostic, layer:, code:)
+          Validation::Issue.new(
+            code:,
+            message: diagnostic.fetch(:message),
+            layer:,
+            line: diagnostic[:line],
+            column: diagnostic[:column],
+            details: error.details.except(:errors).merge(diagnostic.except(:message, :line, :column))
+          )
+        end
+      end
+    end
+  end
+end

data/lib/facturx/xml/schema_registry.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Facturx
+  module Xml
+    class SchemaRegistry
+      SPECIFICATION_VERSION = '1.09.2'
+      ROOT = File.expand_path("../schema/#{SPECIFICATION_VERSION}", __dir__).freeze
+      PATHS = {
+        minimum: 'minimum/Factur-X_1.09.2_MINIMUM.xsd',
+        basic_wl: 'basic-wl/Factur-X_1.09.2_BASICWL.xsd',
+        basic: 'basic/Factur-X_1.09.2_BASIC.xsd',
+        en16931: 'en16931/Factur-X_1.09.2_EN16931.xsd',
+        extended: 'extended/Factur-X_1.09.2_EXTENDED.xsd'
+      }.transform_values { |path| File.join(ROOT, path).freeze }.freeze
+      private_constant :SPECIFICATION_VERSION, :ROOT, :PATHS
+
+      def fetch(profile)
+        PATHS.fetch(profile.id)
+      end
+    end
+  end
+end

data/lib/facturx/xml/schema_validator.rb

@@ -2,6 +2,7 @@
 
 require 'nokogiri'
 require_relative '../error'
+require_relative 'schema_registry'
 
 module Facturx
   module Xml
@@ -27,6 +28,10 @@ module Facturx
         end
       end
 
+      def initialize(registry: SchemaRegistry.new)
+        @registry = registry
+      end
+
       def call(document:, profile:)
         validation_errors = load_schema(profile).validate(document)
         raise_validation_error(profile, validation_errors) unless validation_errors.empty?
@@ -35,7 +40,7 @@ module Facturx
       private
 
       def load_schema(profile)
-        self.class.send(:load_schema, File.expand_path(profile.xsd_path))
+        self.class.send(:load_schema, @registry.fetch(profile))
       rescue SystemCallError, Nokogiri::XML::SyntaxError => e
         raise_schema_load_error(profile, e)
       end
@@ -53,7 +58,7 @@ module Facturx
       end
 
       def raise_schema_load_error(profile, error)
-        raise XsdValidationError.new(
+        raise SchemaLoadError.new(
           "Unable to load the Factur-X #{profile.id} schema",
           profile: profile.id,
           errors: [{ message: error.message }.freeze].freeze

data/lib/facturx/xml/validator.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require_relative '../validation'
+require_relative 'parser'
+require_relative 'profile_detector'
+require_relative 'report_builder'
+require_relative 'conformance_validator'
+
+module Facturx
+  module Xml
+    class Validator
+      def initialize(
+        parser: Parser.new,
+        profile_detector: ProfileDetector.new,
+        conformance_validator: ConformanceValidator.new
+      )
+        @parser = parser
+        @profile_detector = profile_detector
+        @conformance_validator = conformance_validator
+      end
+
+      def call(xml:)
+        document = @parser.call(xml:)
+        profile = @profile_detector.call(document:)
+        issues = @conformance_validator.call(document:, profile:)
+        Validation::Report.new(profile:, issues:)
+      rescue UnknownProfileError => e
+        ReportBuilder.profile(e)
+      rescue XsdValidationError => e
+        ReportBuilder.xsd(profile, e)
+      rescue InvalidXmlError => e
+        ReportBuilder.syntax(e)
+      end
+    end
+  end
+end

data/lib/facturx/xml/verifier.rb

@@ -1,23 +1,29 @@
 # frozen_string_literal: true
 
-require_relative 'parser'
-require_relative 'profile_detector'
-require_relative 'schema_validator'
+require_relative 'validator'
 
 module Facturx
   module Xml
     class Verifier
-      def initialize(parser: Parser.new, profile_detector: ProfileDetector.new, schema_validator: SchemaValidator.new)
-        @parser = parser
-        @profile_detector = profile_detector
-        @schema_validator = schema_validator
+      ERROR_CLASSES = {
+        syntax: InvalidXmlError,
+        profile: UnknownProfileError,
+        xsd: XsdValidationError,
+        schematron: SchematronValidationError
+      }.freeze
+      private_constant :ERROR_CLASSES
+
+      def initialize(validator: Validator.new)
+        @validator = validator
       end
 
       def call(xml:)
-        document = @parser.call(xml: xml)
-        profile = @profile_detector.call(document: document)
-        @schema_validator.call(document: document, profile: profile)
-        profile
+        report = @validator.call(xml:)
+        return report.profile if report.valid?
+
+        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
     end
   end

data/lib/facturx.rb

@@ -16,12 +16,17 @@ require 'facturx/diagnostic'
 require 'facturx/reading'
 require 'facturx/coerce'
 require 'facturx/format'
-require 'facturx/conformance'
+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'
 require 'facturx/pdf/inspector'
 require 'facturx/pdf/extractor'
 require 'facturx/pdf/verifier'
+require 'facturx/pdf/composer'
 require 'facturx/composers/ghostscript'
 require 'facturx/attach'
 require 'facturx/reader'
@@ -29,12 +34,16 @@ require 'facturx/writer'
 require 'facturx/generate'
 
 module Facturx
-  DEFAULT_ATTACHER = Attach.new
+  DEFAULT_XML_VALIDATOR = Xml::Validator.new
+  DEFAULT_PDF_COMPOSER = Pdf::Composer.new
+  DEFAULT_ATTACHER = Attach.new(pdf_composer: DEFAULT_PDF_COMPOSER)
   DEFAULT_READER = Reader.new
   DEFAULT_PROFILE_RESOLVER = ProfileResolver.new
   DEFAULT_WRITER = Writer.new
-  DEFAULT_GENERATOR = Generate.new(writer: DEFAULT_WRITER, attacher: DEFAULT_ATTACHER,
+  DEFAULT_GENERATOR = Generate.new(writer: DEFAULT_WRITER, pdf_composer: DEFAULT_PDF_COMPOSER,
                                    profile_resolver: DEFAULT_PROFILE_RESOLVER)
+  private_constant :DEFAULT_XML_VALIDATOR
+  private_constant :DEFAULT_PDF_COMPOSER
   private_constant :DEFAULT_ATTACHER
   private_constant :DEFAULT_READER
   private_constant :DEFAULT_PROFILE_RESOLVER
@@ -42,9 +51,8 @@ module Facturx
   private_constant :DEFAULT_GENERATOR
 
   class << self
-    def verify_xml(xml:)
-      Xml::Verifier.new.call(xml:)
-      true
+    def validate_xml(xml:)
+      DEFAULT_XML_VALIDATOR.call(xml:)
     end
 
     def attach(pdf:, xml:)
@@ -73,4 +81,8 @@ module Facturx
       DEFAULT_GENERATOR.call(pdf:, document:, profile:)
     end
   end
+
+  private_constant :Attach, :Builders, :Coerce, :CoercionError, :Composers, :Format, :FormattingError,
+                   :Generate, :Group, :Model, :Pdf, :ProfileResolver, :Reader, :SourceReader, :Term,
+                   :SchematronAdapter, :Subprocess, :TermDeclarations, :Terms, :Writer, :Xml
 end