facturx 0.2.0 → 1.1.0

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,32 @@
+# frozen_string_literal: true
+
+require_relative '../validation'
+require_relative 'parser'
+require_relative 'profile_detector'
+require_relative 'report_builder'
+require_relative 'schema_validator'
+
+module Facturx
+  module Xml
+    class Validator
+      def initialize(parser: Parser.new, profile_detector: ProfileDetector.new, schema_validator: SchemaValidator.new)
+        @parser = parser
+        @profile_detector = profile_detector
+        @schema_validator = schema_validator
+      end
+
+      def call(xml:)
+        document = @parser.call(xml:)
+        profile = @profile_detector.call(document:)
+        @schema_validator.call(document:, profile:)
+        Validation::Report.new(profile:)
+      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,28 @@
 # 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
+      }.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.first
+        error_class = ERROR_CLASSES.fetch(issue.layer)
+        raise error_class.new(issue.message, report:, issues: report.issues)
       end
     end
   end

data/lib/facturx.rb

@@ -5,32 +5,51 @@ require 'facturx/error'
 require 'facturx/embedding'
 require 'facturx/profile'
 require 'facturx/profiles'
+require 'facturx/profile_resolver'
 require 'facturx/term'
 require 'facturx/group'
 require 'facturx/terms'
 require 'facturx/model'
+require 'facturx/document'
+require 'facturx/builders'
 require 'facturx/diagnostic'
 require 'facturx/reading'
 require 'facturx/coerce'
+require 'facturx/format'
+require 'facturx/validation'
+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'
+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, 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
+  private_constant :DEFAULT_WRITER
+  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:)
@@ -44,5 +63,23 @@ module Facturx
     def read(source, on_unknown_profile: :fallback)
       DEFAULT_READER.call(source, on_unknown_profile:)
     end
+
+    def validate_document(document:, profile:)
+      canonical_profile = DEFAULT_PROFILE_RESOLVER.call(profile)
+      DEFAULT_WRITER.validate(document:, profile: canonical_profile)
+    end
+
+    def build_xml(document:, profile:)
+      canonical_profile = DEFAULT_PROFILE_RESOLVER.call(profile)
+      DEFAULT_WRITER.call(document:, profile: canonical_profile)
+    end
+
+    def generate(pdf:, document:, profile:)
+      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,
+                   :TermDeclarations, :Terms, :Writer, :Xml
 end