facturx 1.0.0 → 1.2.0

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

@@ -10,12 +10,16 @@ module Facturx
     end
   end
 
-  class InvalidXmlError < Error; end
+  class ValidationError < Error; end
+  class InvalidDocumentError < ValidationError; end
+  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
   class FormattingError < Error; end
-  class ConformanceError < Error; end
   class InvalidPdfError < Error; end
   class ProtectedPdfError < InvalidPdfError; end
   class ComposerUnavailableError < Error; end

data/lib/facturx/generate.rb

@@ -1,21 +1,21 @@
 # frozen_string_literal: true
 
-require_relative 'attach'
+require_relative 'pdf/composer'
 require_relative 'profile_resolver'
 require_relative 'writer'
 
 module Facturx
   class Generate
-    def initialize(writer: Writer.new, attacher: Attach.new, profile_resolver: ProfileResolver.new)
+    def initialize(writer: Writer.new, pdf_composer: Pdf::Composer.new, profile_resolver: ProfileResolver.new)
       @writer = writer
-      @attacher = attacher
+      @pdf_composer = pdf_composer
       @profile_resolver = profile_resolver
     end
 
     def call(pdf:, document:, profile:)
       canonical_profile = @profile_resolver.call(profile)
       xml = @writer.call(document:, profile: canonical_profile)
-      @attacher.call(pdf:, xml:)
+      @pdf_composer.call(pdf:, xml:, profile: canonical_profile)
     end
   end
 end

data/lib/facturx/pdf/composer.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require_relative 'inspector'
+require_relative 'extractor'
+require_relative 'verifier'
+require_relative '../composers/ghostscript'
+
+module Facturx
+  module Pdf
+    class Composer
+      def initialize(
+        inspector: Inspector.new,
+        backend: Composers::Ghostscript.new,
+        extractor: Extractor.new,
+        verifier: Verifier.new
+      )
+        @inspector = inspector
+        @backend = backend
+        @extractor = extractor
+        @verifier = verifier
+      end
+
+      def call(pdf:, xml:, profile:)
+        inspection = @inspector.call(pdf)
+        output = @backend.call(pdf:, xml:, profile:)
+        result = @extractor.call(output)
+        @verifier.call(result:, expected_xml: xml, expected_page_count: inspection.page_count, profile:)
+        output
+      end
+    end
+  end
+end

data/lib/facturx/profile.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Facturx
-  Profile = Data.define(:id, :guideline_urn, :xsd_path, :conformance_level)
+  Profile = Data.define(:id, :guideline_urn, :conformance_level)
 end

data/lib/facturx/profiles.rb

@@ -4,44 +4,37 @@ require_relative 'profile'
 
 module Facturx
   module Profiles
-    SPECIFICATION_VERSION = '1.09.2'
-    SCHEMA_ROOT = File.expand_path("schema/#{SPECIFICATION_VERSION}", __dir__).freeze
-
     ALL = [
       Profile.new(
         id: :minimum,
         guideline_urn: 'urn:factur-x.eu:1p0:minimum',
-        xsd_path: File.join(SCHEMA_ROOT, 'minimum/Factur-X_1.09.2_MINIMUM.xsd').freeze,
         conformance_level: 'MINIMUM'
       ),
       Profile.new(
         id: :basic_wl,
         guideline_urn: 'urn:factur-x.eu:1p0:basicwl',
-        xsd_path: File.join(SCHEMA_ROOT, 'basic-wl/Factur-X_1.09.2_BASICWL.xsd').freeze,
         conformance_level: 'BASIC WL'
       ),
       Profile.new(
         id: :basic,
         guideline_urn: 'urn:cen.eu:en16931:2017#compliant#urn:factur-x.eu:1p0:basic',
-        xsd_path: File.join(SCHEMA_ROOT, 'basic/Factur-X_1.09.2_BASIC.xsd').freeze,
         conformance_level: 'BASIC'
       ),
       Profile.new(
         id: :en16931,
         guideline_urn: 'urn:cen.eu:en16931:2017',
-        xsd_path: File.join(SCHEMA_ROOT, 'en16931/Factur-X_1.09.2_EN16931.xsd').freeze,
         conformance_level: 'EN 16931'
       ),
       Profile.new(
         id: :extended,
         guideline_urn: 'urn:cen.eu:en16931:2017#conformant#urn:factur-x.eu:1p0:extended',
-        xsd_path: File.join(SCHEMA_ROOT, 'extended/Factur-X_1.09.2_EXTENDED.xsd').freeze,
         conformance_level: 'EXTENDED'
       )
     ].freeze
 
     BY_ID = ALL.to_h { |profile| [profile.id, profile] }.freeze
     BY_GUIDELINE_URN = ALL.to_h { |profile| [profile.guideline_urn, profile] }.freeze
+    private_constant :ALL, :BY_ID, :BY_GUIDELINE_URN
 
     module_function
 

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

@@ -13,7 +13,7 @@ module Facturx
 
     def call(source)
       unless source.is_a?(String)
-        raise InvalidXmlError.new('Source must be provided as a byte String', input_class: source.class.name)
+        raise InvalidSourceError.new('Source must be provided as a byte String', input_class: source.class.name)
       end
 
       return Result.new(xml: source, source_type: :xml) unless pdf?(source)

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

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require_relative 'error'
+require_relative 'model/immutable'
+
+module Facturx
+  module Validation
+    LAYERS = %i[syntax profile document xsd schematron].freeze
+    SEVERITIES = %i[error warning].freeze
+    ISSUE_DEFAULTS = {
+      severity: :error,
+      term_id: nil,
+      group_id: nil,
+      path: nil,
+      line: nil,
+      column: nil,
+      details: {}
+    }.freeze
+    private_constant :LAYERS, :SEVERITIES, :ISSUE_DEFAULTS
+
+    Issue = Data.define(:code, :message, :layer, :severity, :term_id, :group_id, :path, :line, :column, :details) do
+      include Model::ValidatedWith
+
+      def initialize(**attributes)
+        Model.validate_attributes!(self.class.members, attributes)
+        attributes.fetch_values(:code, :message, :layer)
+        values = ISSUE_DEFAULTS.merge(attributes)
+        validate_values!(values)
+
+        super(**values.transform_values { |value| Model.copy_and_freeze(value) })
+      end
+
+      private
+
+      def validate_values!(values)
+        unless LAYERS.include?(values[:layer])
+          raise ArgumentError, "Unknown validation layer: #{values[:layer].inspect}"
+        end
+        unless SEVERITIES.include?(values[:severity])
+          raise ArgumentError, "Unknown validation severity: #{values[:severity].inspect}"
+        end
+        raise TypeError, 'details must be a Hash' unless values[:details].is_a?(Hash)
+      end
+    end
+
+    Report = Data.define(:profile, :issues) do
+      include Model::ValidatedWith
+
+      def initialize(profile: nil, issues: [])
+        raise TypeError, 'issues must be an Array' unless issues.is_a?(Array)
+        raise TypeError, 'issues must contain validation issues' unless issues.all?(Issue)
+
+        super(profile: Model.copy_and_freeze(profile), issues: Model.copy_and_freeze(issues))
+      end
+
+      def valid? = issues.none? { |issue| issue.severity == :error }
+
+      def invalid? = !valid?
+    end
+  end
+end

data/lib/facturx/version.rb

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