libis-format 1.3.0 → 1.3.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b8282db4cf37eea292436474d401bcc2725c31eaa1eb882ea9475be14912f6c9
-  data.tar.gz: 6eaf1dfe05d24bd0df1ad20f61137a4007f02828b97138601c87afc5215d7454
+  metadata.gz: e8f7ecb168b9a5db9a47b91035c1f8988c8a079963ad0764e23ad00b2bde61b1
+  data.tar.gz: 2fecf5a7eb4f0a74573d8182111dac6bb4abc05e9c8d22c248b79cc6533a93ef
 SHA512:
-  metadata.gz: 8a242dc0d21da39ec434a7e2f59b2d8ff3c57e427512909c792bce05de5a29a03fdc726484059f13dc0b931f4ec2be13e75dc06f0e06b8736d77c541fd6aeb7e
-  data.tar.gz: 34a6d942f8fc39392528d03e5d367d8d476c58da12424ba5a8a87b4cf749a85ca485dba6ee1741dd5b865a25aaa57d562c1b97d96f03af83a5485f4c142dcdeb
+  metadata.gz: 4ea0eced4ca98790237cbb936cd347964693a0b5d627e9564fb184621d018868d69e6208c5afc2cbaf78db096e5a7342fa42af9604921bf411b3b2c70c4e8722
+  data.tar.gz: 339f5f89b61747862d2f005ede140300f09ae8ab9aee4693d0214edac3bfba52b8f8b2eaa04b9e1e499debdee805403f1e8434c3ef7907d4ea0ae86e54bdc01f

data/Gemfile

@@ -6,10 +6,12 @@ gem 'coveralls', group: :test, require: false
 
 gemspec name: 'libis-format', development_group: :test
 
-gem 'gem-release'
-
 group :development do
   gem 'byebug'
   gem 'debug'
   gem 'standard'
 end
+
+# Gem publishing and changelog
+gem 'gem-release'
+gem 'github_changelog_generator'

data/bin/{pdf_copy → pdf_tool}

@@ -5,9 +5,10 @@ require 'libis-tools'
 
 ::Libis::Tools::Config.logger.level = :WARN
 
+command = ARGV.shift
+command = command.split('_')
 source = ARGV.shift
 target = ARGV.shift
 options = ARGV
 
-::Libis::Format::Tool::PdfCopy.run source, target, options
-
+::Libis::Format::Tool::PdfTool.run command, source, target, *options

data/lib/libis/format/config.rb

@@ -20,7 +20,7 @@ module Libis
     Config[:ffmpeg_cmd] = 'ffmpeg'
     Config[:fido_formats] = [File.join(Libis::Format::DATA_DIR, 'lias_formats.xml')]
     Config[:pdf_tool] = File.join(Libis::Format::TOOL_DIR, 'PdfTool.jar')
-    Config[:preflight_jar] = File.join(Libis::Format::TOOL_DIR, 'pdfbox', 'preflight-app-2.0.13.jar')
+    Config[:preflight_jar] = File.join(Libis::Format::TOOL_DIR, 'pdfbox', 'preflight-app-3.0.3.jar')
     Config[:wkhtmltopdf] = 'wkhtmltopdf'
     Config[:xml_validations] = [['archive/ead', File.join(Libis::Format::DATA_DIR, 'ead.xsd')]]
     Config[:type_database] = File.join(Libis::Format::DATA_DIR, 'types.yml')
@@ -35,10 +35,8 @@ module Libis
       identification_tool: 5 * 60,
       office_to_pdf: 5 * 60,
       email2pdf: 5 * 60,
-      pdf_copy: 5 * 60,
-      pdf_merge: 5 * 60,
+      pdf_tool: 5 * 60,
       pdf_optimizer: 5 * 60,
-      pdf_split: 5 * 60,
       pdf_to_pdfa: 5 * 60,
       pdfa_validator: 5 * 60
     }

data/lib/libis/format/converter/pdf_converter.rb

@@ -3,7 +3,7 @@
 require_relative 'base'
 
 require 'libis/tools/extend/hash'
-require 'libis/format/tool/pdf_copy'
+require 'libis/format/tool/pdf_tool'
 require 'libis/format/tool/pdf_to_pdfa'
 require 'libis/format/tool/pdfa_validator'
 require 'libis/format/tool/pdf_optimizer'
@@ -40,15 +40,14 @@ module Libis
           values.key_strings_to_symbols!
           values.each do |k, v|
             next unless %i[title author creator keywords subject].include?(k)
-
-            @options["md_#{k}"] = v
+            (@options[:metadata] ||= {})[k] = v
           end
         end
 
         # Select a partial list of pages
         # @param [String] selection as described in com.itextpdf.text.pdf.SequenceList: [!][o][odd][e][even]start-end
         def range(selection)
-          @options[:ranges] = selection
+          @options[:select] = {range: [selection].flatten.compact.join(',')}
         end
 
         # Create or use a watermark image.
@@ -56,6 +55,7 @@ module Libis
         # The watermark options are (use symbols):
         #     - text: text to create a watermark from
         #     - file: watermark image to use
+        #     - image: same as above
         #     - rotation: rotation of the watermark text (in degrees; integer number)
         #     - size: font size of the watermark text
         #     - opacity: opacity of the watermark (fraction 0.0 - 1.0)
@@ -70,16 +70,56 @@ module Libis
         # @param [Hash] options Hash of options for watermark creation.
         def watermark(options = {})
           options.key_strings_to_symbols!
-          if options[:file] && File.exist?(options[:file])
-            @options['wm_image'] = options[:file]
-          else
-            @options['wm_text'] = (options[:text] || '© LIBIS').split('\n')
-            @options['wm_text_rotation'] = options[:rotation] if options[:rotation]
-            @options['wm_font_size'] = options[:size] if options[:size]
+          if options[:file] || options[:image]
+            watermark_image(options)
+          elsif options[:text]
+            watermark_text(options)
+          elsif options[:banner]
+            watermark_banner(options)
           end
-          @options['wm_opacity'] = options[:opacity] || '0.3'
-          @options['wm_gap_ratio'] = options[:gap] if options[:gap].to_s =~ /^\s*(0+\.\d+|1\.0+)\s*$/
-          @options['wm_gap_size'] = options[:gap] if options[:gap].to_s =~ /^\s*\d+\s*$/
+        end
+
+        def watermark_image(options = {})
+          options.key_strings_to_symbols!
+          @options[:watermark] = {command: 'image'}
+          @options[:watermark][:data] = options[:file] || options[:image]
+          @options[:watermark][:opacity] = options[:opacity] || '0.3'
+
+        end
+
+        def watermark_text(options = {})
+          options.key_strings_to_symbols!
+          @options[:watermark] = {command: 'text'}
+          @options[:watermark][:data] = (options[:text] || '© LIBIS').split('\n')
+          @options[:watermark][:rotation] = options[:rotation] if options[:rotation]
+          @options[:watermark][:size] = options[:size] if options[:size]
+          @options[:watermark][:gap] = options[:gap] if options[:gap].to_s =~ /^\s*\d+\s*$/
+          @options[:watermark][:padding] = options[:gap] if options[:gap].to_s =~ /^\s*(0+\.\d+|1\.0+)\s*$/
+          @options[:watermark][:padding] = options[:padding] if options[:padding]
+          @options[:watermark][:opacity] = options[:opacity] || '0.3'
+        end
+
+        # Create a vertical banner to the right side of each page
+        #
+        # The banner options are:
+        # - banner: text to put in the banner
+        # - add_filename: append filename to the text (use any value to enable)
+        # - fontsize: size of the font (in points)
+        # - width: width of the banner
+        # - (background|text)_color_(red|green|blue): color components of background and text
+        def watermark_banner(options = {})
+          options.key_strings_to_symbols!
+          @options[:watermark] = {command: 'banner'}
+          @options[:watermark][:data] = (options[:banner] || '© LIBIS')
+          @options[:watermark][:add_filename] = !!options[:add_filename]
+          @options[:watermark][:size] = options[:fontsize] if options[:fontsize]
+          @options[:watermark][:width] = options[:width] if options[:width]
+          @options[:watermark][:background_red] = options[:background_color_red] if options[:background_color_red]
+          @options[:watermark][:background_green] = options[:background_color_green] if options[:background_color_green]
+          @options[:watermark][:background_blue] = options[:background_color_blue] if options[:background_color_blue]
+          @options[:watermark][:text_red] = options[:text_color_red] if options[:text_color_red]
+          @options[:watermark][:text_green] = options[:text_color_green] if options[:text_color_green]
+          @options[:watermark][:text_blue] = options[:text_color_blue] if options[:text_color_blue]
         end
 
         # Optimize the PDF
@@ -89,7 +129,7 @@ module Libis
         #
         # - 0 : lowest quality (Acrobat Distiller 'Screen Optimized' equivalent)
         # - 1 : medium quality (Acrobat Distiller 'eBook' equivalent)
-        # - 2 : good quality
+        # - 2 : good quality (Acrobat Distiller 'Default' equivalent)
         # - 3 : high quality (Acrobat Distiller 'Print Optimized' equivalent)
         # - 4 : highest quality (Acrobat Distiller 'Prepress Optimized' equivalent)
         #
@@ -97,7 +137,7 @@ module Libis
         #
         # @param [Integer] setting quality setting. [0-4]
         def optimize(setting = 1)
-          @options['optimize'] = %w[screen ebook default printer prepress][setting] if (0..4).include?(setting)
+          @options[:optimize] = %w[screen ebook default printer prepress][setting] if (0..4).include?(setting)
         end
 
         def convert(source, target, format, opts = {})
@@ -105,21 +145,19 @@ module Libis
 
           result = nil
 
-          if (quality = @options.delete('optimize'))
-            result = optimize_pdf(source, target, quality)
-            return nil unless result
-
-            source = result
-          end
-
           unless @options.empty?
             result = convert_pdf(source, target)
-            return nil unless result
+            source = result
+          end
 
+          if source && (quality = @options.delete(:optimize))
+            result = optimize_pdf(source, target, quality)
             source = result
           end
 
-          result = pdf_to_pdfa(source, target) if (format == :PDFA) && source
+          if source && (format == :PDFA)
+            result = pdf_to_pdfa(source, target)
+          end
 
           {
             files: [result],
@@ -127,32 +165,81 @@ module Libis
           }
         end
 
+        protected
+
         def optimize_pdf(source, target, quality)
           using_temp(target) do |tmpname|
             result = Libis::Format::Tool::PdfOptimizer.run(source, tmpname, quality)
-            unless (result[:status]).zero?
+            unless result[:err].empty?
               error("Pdf optimization encountered errors:\n%s", (result[:err] + result[:out]).join("\n"))
-              next nil
+              return nil
             end
             tmpname
           end
         end
 
         def convert_pdf(source, target)
+          result = source
+          result = add_watermark(result, target, @options[:watermark]) if @options[:watermark]
+          result = add_metadata(result, target, @options[:metadata]) if @options[:metadata]
+          result = select_range(result, target, @options[:select]) if @options[:select]
+          return result
+        end
+
+        def options_to_args(options)
+          options.map do |k, v|
+            key = "--#{k.to_s.tr_s('_', '-')}"
+            value = v
+            case value
+            when TrueClass
+              value = nil
+            when FalseClass
+              value = key = nil
+            when Array
+              value = value.map(&:to_s)
+            else
+              value = v.to_s
+            end
+            [key, value]
+          end.flatten.compact
+        end
+
+        def add_watermark(source, target, options)
+          command = options.delete(:command)
+          data = [options.delete(:data)].flatten.compact
+          args = data + options_to_args(options)
+
+          using_temp(target) do |tmpname|
+            result = Libis::Format::Tool::PdfTool.run(['watermark', command], source, tmpname, *args)
+            unless result[:err].empty?
+              error("Pdf watermarking encountered errors:\n%s", result[:err].join(join("\n")))
+              return nil
+            end
+            tmpname
+          end
+        end
+
+        def add_metadata(source, target, options)
+          args = options_to_args(options)
+
+          using_temp(target) do |tmpname|
+            result = Libis::Format::Tool::PdfTool.run('metadata', source, tmpname, *args)
+            unless result[:err].empty?
+              error("Pdf metadata encountered errors:\n%s", result[:err].join(join("\n")))
+              return nil
+            end
+            tmpname
+          end
+        end
+
+        def select_range(source, target, options)
+          args = options_to_args(options)
+
           using_temp(target) do |tmpname|
-            result = Libis::Format::Tool::PdfCopy.run(
-              source, tmpname,
-              @options.map do |k, v|
-                if v.nil?
-                  nil
-                else
-                  ["--#{k}", (v.is_a?(Array) ? v : v.to_s)]
-                end
-              end.flatten
-            )
+            result = Libis::Format::Tool::PdfTool.run('select', source, tmpname, *args)
             unless result[:err].empty?
-              error("Pdf conversion encountered errors:\n%s", result[:err].join(join("\n")))
-              next nil
+              error("Pdf select encountered errors:\n%s", result[:err].join(join("\n")))
+              return nil
             end
             tmpname
           end
@@ -162,14 +249,14 @@ module Libis
           using_temp(target) do |tmpname|
             result = Libis::Format::Tool::PdfToPdfa.run source, tmpname
 
-            if result[:command][:status] != 0
-              error("Pdf/A conversion encountered errors:\n%s", (result[:command][:out] + result[:command][:err]).join("\n"))
-              next nil
+            unless result[:status].zero?
+              error("Pdf/A conversion encountered errors:\n%s", (result[:out] + result[:err]).join("\n"))
+              return nil
             else
               r = Libis::Format::Tool::PdfaValidator.run tmpname
               if r[:status] != 0
                 error "Pdf/A file failed to validate with following errors:\n%s", (r[:err] || r[:out] || []).join("\n")
-                next nil
+                return nil
               end
             end
             tmpname

data/lib/libis/format/tool/pdf_merge.rb

@@ -21,36 +21,32 @@ module Libis
           File.exist?(Libis::Format::Config[:pdf_tool])
         end
 
-        def self.run(source, target, options = [])
+        def self.run(source, target, *options)
           new.run source, target, options
         end
 
-        def run(source, target, options = [])
+        def run(source, target, *options)
           source = [source] unless source.is_a?(Array)
 
           if OS.java?
             # TODO: import library and execute in current VM. For now do exactly as in MRI.
           end
 
-          timeout = Libis::Format::Config[:timeouts][:pdf_merge]
-          result = Libis::Tools::Command.run(
+          timeout = Libis::Format::Config[:timeouts][:pdf_tool]
+          args = [
             Libis::Format::Config[:java_cmd],
-            '-cp', Libis::Format::Config[:pdf_tool],
-            'MergePdf',
-            '--file_output', target,
-            *options,
-            *source,
-            timeout:,
-            kill_after: timeout * 2
-          )
-
-          raise "#{self.class} took too long (> #{timeout} seconds) to complete" if result[:timeout]
-          raise "#{self.class} errors: #{result[:err].join("\n")}" unless (result[:status]).zero? && result[:err].empty?
-
-          {
-            command: result,
-            files: [target]
-          }
+            '-jar', Libis::Format::Config[:pdf_tool],
+            'merge',
+            '-o', target,
+            options,
+            source
+          ].flatten
+
+          result = Libis::Tools::Command.run(*args, timeout: , kill_after: timeout * 2)
+
+          result[:err] << "#{self.class} took too long (> #{timeout} seconds) to complete" if result[:timeout]
+
+          result
         end
       end
     end

data/lib/libis/format/tool/pdf_optimizer.rb

@@ -25,7 +25,7 @@ module Libis
 
         def run(source, target, quality)
           timeout = Libis::Format::Config[:timeouts][:pdf_optimizer]
-          result = Libis::Tools::Command.run(
+          args = [
             Libis::Format::Config[:ghostscript_cmd],
             '-sDEVICE=pdfwrite',
             '-dCompatibilityLevel=1.4',
@@ -33,18 +33,14 @@ module Libis
             '-dNOPAUSE',
             '-dBATCH',
             "-sOutputFile=#{target}",
-            source.to_s,
-            timeout:,
-            kill_after: timeout * 2
-          )
-
-          raise "#{self.class} took too long (> #{timeout} seconds) to complete" if result[:timeout]
-          raise "#{self.class} errors: #{result[:err].join("\n")}" unless (result[:status]).zero?
-
-          {
-            command: result,
-            files: [target]
-          }
+            source.to_s
+          ]
+
+          result = Libis::Tools::Command.run(*args, timeout:, kill_after: timeout * 2)
+
+          result[:err] << "#{self.class} took too long (> #{timeout} seconds) to complete" if result[:timeout]
+
+          result
         end
       end
     end

data/lib/libis/format/tool/pdf_split.rb

@@ -1,54 +1,18 @@
 # frozen_string_literal: true
 
-require 'os'
-
-require 'libis/tools/extend/string'
-require 'libis/tools/logger'
-require 'libis/tools/command'
-
-require 'libis/format/config'
+require 'libis/format/tool/pdf_tool'
 
 module Libis
   module Format
     module Tool
       class PdfSplit
-        include ::Libis::Tools::Logger
-
-        def self.installed?
-          result = Libis::Tools::Command.run(Libis::Format::Config[:java_cmd], '-version')
-          return false unless (result[:status]).zero?
-
-          File.exist?(Libis::Format::Config[:pdf_tool])
-        end
 
-        def self.run(source, target, *args)
-          new.run source, target, *args
+        def self.run(source, target, *options)
+          PdfTool.run('split', source, target, *options)
         end
 
-        def run(source, target, *args)
-          if OS.java?
-            # TODO: import library and execute in current VM. For now do exactly as in MRI.
-          end
-
-          timeout = Libis::Format::Config[:timeouts][:pdf_split]
-          result = Libis::Tools::Command.run(
-            Libis::Format::Config[:java_cmd],
-            '-cp', Libis::Format::Config[:pdf_tool],
-            'SplitPdf',
-            '--file_input', source,
-            '--file_output', target,
-            *args,
-            timeout:,
-            kill_after: timeout * 2
-          )
-
-          raise "#{self.class} took too long (> #{timeout} seconds) to complete" if result[:timeout]
-          raise "#{self.class} errors: #{result[:err].join("\n")}" unless (result[:status]).zero? && result[:err].empty?
-
-          {
-            command: result,
-            files: [target] # TODO: collect the files
-          }
+        def run(source, target, *options)
+          PdfTool.run('split', source, target, *options)
         end
       end
     end

data/lib/libis/format/tool/pdf_to_pdfa.rb

@@ -64,15 +64,11 @@ module Libis
             kill_after: timeout * 2
           )
 
-          raise "#{self.class} took too long (> #{timeout} seconds) to complete" if result[:timeout]
-          raise "#{self.class} failed with error #{result[:status]}: \n#{(result[:out] + result[:err]).join("\n")}" if result[:status] != 0
+          result[:err] << "#{self.class} took too long (> #{timeout} seconds) to complete" if result[:timeout]
 
           FileUtils.rm [icc_file, def_filename].compact, force: true
 
-          {
-            command: result,
-            files: [target]
-          }
+          result
         end
 
         private

data/lib/libis/format/tool/pdf_tool.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require 'os'
+
+require 'libis/tools/extend/string'
+require 'libis/tools/logger'
+require 'libis/tools/command'
+
+require 'libis/format/config'
+
+module Libis
+  module Format
+    module Tool
+      class PdfTool
+        include ::Libis::Tools::Logger
+
+        def self.installed?
+          result = Libis::Tools::Command.run(Libis::Format::Config[:java_cmd], '-version')
+          return false unless (result[:status]).zero?
+
+          File.exist?(Libis::Format::Config[:pdf_tool])
+        end
+
+        def self.run(command, source, target, *options)
+          new.run command, source, target, *options
+        end
+
+        def run(command, source, target, *options)
+          if OS.java?
+            # TODO: import library and execute in current VM. For now do exactly as in MRI.
+          end
+
+          timeout = Libis::Format::Config[:timeouts][:pdf_tool]
+          args = [
+            Libis::Format::Config[:java_cmd],
+            '-jar', Libis::Format::Config[:pdf_tool],
+            [command],
+            '-i', source,
+            '-o', target,
+            options,
+          ].flatten
+
+          result = Libis::Tools::Command.run(*args, timeout: , kill_after: timeout * 2)
+
+          result[:err] << "#{self.class} took too long (> #{timeout} seconds) to complete" if result[:timeout]
+
+          result
+        end
+      end
+    end
+  end
+end

data/lib/libis/format/tool/pdfa_validator.rb

@@ -38,8 +38,7 @@ module Libis
               kill_after: timeout * 2
             )
 
-            raise "#{self.class} took too long (> #{timeout} seconds) to complete" if result[:timeout]
-            raise "#{self.class} errors: #{result[:err].join("\n")}" unless (result[:status]).zero? && result[:err].empty?
+            result[:err] << "#{self.class} took too long (> #{timeout} seconds) to complete" if result[:timeout]
 
             Dir.chdir(previous_wd)
 
@@ -57,7 +56,7 @@ module Libis
               kill_after: timeout * 2
             )
 
-            raise "#{self.class} took too long (> #{timeout} seconds) to complete" if result[:timeout]
+            result[:err] << "#{self.class} took too long (> #{timeout} seconds) to complete" if result[:timeout]
 
           end
           result

data/lib/libis/format/type_database_impl.rb

@@ -90,7 +90,7 @@ module Libis
       end
 
       def groups
-        @types.values.map(&:dig.call(:GROUP)).uniq
+        @types.values.map(&:dig.with(:GROUP)).uniq
       end
 
       def export_csv(filename, **options)

data/lib/libis/format/version.rb

@@ -2,6 +2,6 @@
 
 module Libis
   module Format
-    VERSION = '1.3.0'
+    VERSION = '1.3.3'
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: libis-format
 version: !ruby/object:Gem::Version
-  version: 1.3.0
+  version: 1.3.3
 platform: ruby
 authors:
 - Kris Dekeyser
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2024-03-16 00:00:00.000000000 Z
+date: 2024-09-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: chromaprint
@@ -229,7 +229,7 @@ executables:
 - fido_tool
 - formatinfo
 - libis_format
-- pdf_copy
+- pdf_tool
 extensions: []
 extra_rdoc_files: []
 files:
@@ -240,7 +240,7 @@ files:
 - bin/fido_tool
 - bin/formatinfo
 - bin/libis_format
-- bin/pdf_copy
+- bin/pdf_tool
 - data/AdobeRGB1998.icc
 - data/ISOcoated_v2_eci.icc
 - data/PDFA_def.ps
@@ -281,11 +281,11 @@ files:
 - lib/libis/format/tool/identification_tool.rb
 - lib/libis/format/tool/msg_to_pdf.rb
 - lib/libis/format/tool/office_to_pdf.rb
-- lib/libis/format/tool/pdf_copy.rb
 - lib/libis/format/tool/pdf_merge.rb
 - lib/libis/format/tool/pdf_optimizer.rb
 - lib/libis/format/tool/pdf_split.rb
 - lib/libis/format/tool/pdf_to_pdfa.rb
+- lib/libis/format/tool/pdf_tool.rb
 - lib/libis/format/tool/pdfa_validator.rb
 - lib/libis/format/tool/spreadsheet_to_ods.rb
 - lib/libis/format/type_database.rb
@@ -346,8 +346,8 @@ files:
 - tools/fop/lib/xmlgraphics-commons.LICENSE.txt
 - tools/fop/lib/xmlgraphics-commons.NOTICE.txt
 - tools/pdf2pdfa
-- tools/pdfbox/pdfbox-app-2.0.13.jar
-- tools/pdfbox/preflight-app-2.0.13.jar
+- tools/pdfbox/pdfbox-app-3.0.3.jar
+- tools/pdfbox/preflight-app-3.0.3.jar
 homepage: ''
 licenses:
 - MIT
@@ -367,7 +367,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.1
+rubygems_version: 3.5.18
 signing_key: 
 specification_version: 4
 summary: LIBIS File format format services.

data/lib/libis/format/tool/pdf_copy.rb

@@ -1,56 +0,0 @@
-# frozen_string_literal: true
-
-require 'os'
-
-require 'libis/tools/extend/string'
-require 'libis/tools/logger'
-require 'libis/tools/command'
-
-require 'libis/format/config'
-
-module Libis
-  module Format
-    module Tool
-      class PdfCopy
-        include ::Libis::Tools::Logger
-
-        def self.installed?
-          result = Libis::Tools::Command.run(Libis::Format::Config[:java_cmd], '-version')
-          return false unless (result[:status]).zero?
-
-          File.exist?(Libis::Format::Config[:pdf_tool])
-        end
-
-        def self.run(source, target, options = [])
-          new.run source, target, options
-        end
-
-        def run(source, target, options = [])
-          if OS.java?
-            # TODO: import library and execute in current VM. For now do exactly as in MRI.
-          end
-
-          timeout = Libis::Format::Config[:timeouts][:pdf_copy]
-          result = Libis::Tools::Command.run(
-            Libis::Format::Config[:java_cmd],
-            '-cp', Libis::Format::Config[:pdf_tool],
-            'CopyPdf',
-            '--file_input', source,
-            '--file_output', target,
-            *options,
-            timeout:,
-            kill_after: timeout * 2
-          )
-
-          raise "#{self.class} took too long (> #{timeout} seconds) to complete" if result[:timeout]
-          raise "#{self.class} errors: #{result[:err].join("\n")}" unless (result[:status]).zero? && result[:err].empty?
-
-          {
-            command: result,
-            files: [target]
-          }
-        end
-      end
-    end
-  end
-end