libis-format 1.3.4 → 2.0.0

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

@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 require 'csv'
 require 'tmpdir'
 
@@ -9,46 +7,47 @@ require 'libis/tools/logger'
 require 'libis/tools/command'
 
 require 'libis/format/config'
-require 'libis/format/type_database'
+require 'libis/format/library'
 
 module Libis
   module Format
     module Tool
-      class IdentificationTool
+
+        class IdentificationTool
         include Singleton
         include ::Libis::Tools::Logger
 
         def self.bad_mimetype(mimetype)
-          instance.bad_mimetype(mimetype)
+          self.instance.bad_mimetype(mimetype)
         end
 
-        def self.run(file, recursive = false, **options)
+        def self.run(file, recursive = false, options = {})
+          options ||= {}
           if file.is_a?(Array)
-            return run_list file, **options
-          elsif file.is_a?(String) && File.exist?(file) && File.readable?(file)
+            return run_list file, options
+          elsif file.is_a?(String) && File.exists?(file) && File.readable?(file)
             if File.directory?(file)
-              return run_dir(file, recursive, **options)
+              return run_dir(file, recursive, options)
             elsif File.file?(file)
-              return instance.run(file, **options)
+              return self.instance.run(file, options)
             end
           end
-
           raise ArgumentError,
                 'IdentificationTool: file argument should be a path to an existing file or directory or a list of those'
         end
 
-        def self.run_dir(file, recursive = true, **options)
-          instance.run_dir file, recursive, **options
+        def self.run_dir(file, recursive = true, options = {})
+          self.instance.run_dir file, recursive, options
         end
 
-        def self.run_list(filelist, **options)
-          instance.run_list filelist, **options
+        def self.run_list(filelist , options = {})
+          self.instance.run_list filelist, options
         end
 
         protected
 
         def create_list_file(filelist)
-          list_file = Tempfile.new(%w[file .list])
+          list_file = Tempfile.new(%w'file .list')
           filelist.each do |fname|
             list_file.write "#{fname}\n"
           end
@@ -84,22 +83,23 @@ module Libis
         #   { mimetype: <mimetype>, puid: <puid>, matchtype: <matchtype>, score: <score>, ...}
         #
         def process_output(output)
-          output.each_with_object({}) do |x, results|
+          output.reduce({}) do |results, x|
             filepath = File.absolute_path(x.delete(:filepath)).freeze
             results[filepath] ||= []
             results[filepath] << annotate(x)
+            results
           end
         end
 
         # Enhance the output with mimetype and score
         def annotate(result)
           # Enhance result with mimetype if needed
-          bad_mimetypes.include?(result[:mimetype]) &&
-            !bad_puids.include?(result[:puid]) &&
+          if bad_mimetypes.include?(result[:mimetype]) && !bad_puids.include?(result[:puid])
             result[:mimetype] = get_mimetype(result[:puid])
+          end
 
           # Normalize the mimetype
-          Libis::Format::TypeDatabase.normalize(result, PUID: :puid, MIME: :mimetype)
+          Libis::Format::Library.normalize(result)
 
           # Default score is 5
           result[:score] = 5
@@ -108,54 +108,55 @@ module Libis
           result[:score] = 1 if bad_mimetypes.include? result[:mimetype]
 
           # freeze all strings
-          result.each { |_, v| v.freeze if v.is_a?(String) }
+          result.each {|_, v| v.freeze if v.is_a?(String)}
 
           # Adapt score based on matchtype
           result[:matchtype] = result[:matchtype].to_s.downcase
           case result[:matchtype]
 
             # Signature match increases score with 2
-          when 'signature'
-            result[:score] += 2
-            # typeinfo = ::Libis::Format::TypeDatabase.puid_typeinfo(result[:puid])
+            when 'signature'
+              result[:score] += 2
+            # typeinfo = ::Libis::Format::Library.get_info_by(:puid, result[:puid])
             # ext = File.extname(result[:filename])
             # result[:score] += 1 if typeinfo and typeinfo[:EXTENSIONS].include?(ext)
 
             # Container match increases score with 4
-          when 'container'
-            result[:score] += 4
-            # typeinfo = ::Libis::Format::TypeDatabase.puid_typeinfo(result[:puid])
+            when 'container'
+              result[:score] += 4
+            # typeinfo = ::Libis::Format::Library.get_info_by(:puid, result[:puid])
             # ext = File.extname(result[:filename])
             # result[:score] += 1 if typeinfo and typeinfo[:EXTENSIONS].include?(ext)
 
             # Extension match is the weakest identification; score is lowered by 2 points
-          when 'extension'
-            result[:score] -= 2
+            when 'extension'
+              result[:score] -= 2
 
             # Magic code (file tool) is to be trused even less
-          when 'magic'
-            result[:score] -= 3
+            when 'magic'
+              result[:score] -= 3
 
+            # Or no change otherwise
+            else
+              # do nothing
           end
 
           # Detecting a zip file should decrease the score as it may hide one of the many zip-based formats (e.g. epub,
           # Office OpenXML, OpenDocument, jar, maff, svx)
-          result[:score] -= 2 if result[:mimetype] == 'application/zip'
+          if result[:mimetype] == 'application/zip'
+            result[:score] -= 2
+          end
 
           # Return result enhanced with mimetype and score fields
           result
         end
 
         def get_mimetype(puid)
-          ::Libis::Format::TypeDatabase.puid_typeinfo(puid)[:MIME].first
-        rescue StandardError
-          nil
+          ::Libis::Format::Library.get_field_by(:puid, puid, :mimetype) rescue nil
         end
 
         def get_puid(mimetype)
-          ::Libis::Format::TypeDatabase.mime_infos(mimetype).first[:PUID].first
-        rescue StandardError
-          nil
+          ::Libis::Format::Library.get_field_by(:mimetype, mimetype, :puid) rescue nil
         end
 
         attr_accessor :bad_mimetypes, :bad_puids
@@ -169,6 +170,7 @@ module Libis
           @bad_mimetypes << mimetype
         end
       end
+
     end
   end
 end

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

@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 require 'fileutils'
 
 require 'libis/tools/extend/string'
@@ -11,61 +9,51 @@ require 'libis/format/config'
 module Libis
   module Format
     module Tool
+
       class OfficeToPdf
         include ::Libis::Tools::Logger
 
-        def self.installed?
-          result = Libis::Tools::Command.run(Libis::Format::Config[:soffice_cmd], '--version')
-          (result[:status]).zero?
-        end
-
-        def self.run(source, target, **options)
-          new.run source, target, **options
+        def self.run(source, target, options = {})
+          self.new.run source, target, options
         end
 
-        def run(source, target, **options)
+        def run(source, target, options = {})
           workdir = '/...'
           workdir = Dir.tmpdir unless Dir.exist? workdir
 
-          workdir = File.join(workdir, rand(1_000_000).to_s)
+          workdir = File.join(workdir, rand(1000000).to_s)
           FileUtils.mkpath(workdir)
 
           src_file = File.join(workdir, File.basename(source))
           FileUtils.symlink source, src_file
 
-          tgt_file = File.join(workdir, "#{File.basename(source, '.*')}.pdf")
+          tgt_file = File.join(workdir, File.basename(source, '.*') + '.pdf')
 
           export_filter = options[:export_filter] || 'pdf'
 
           timeout = Libis::Format::Config[:timeouts][:office_to_pdf]
           result = Libis::Tools::Command.run(
-            Libis::Format::Config[:soffice_cmd], '--headless',
-            "-env:UserInstallation=file://#{workdir}",
-            '--convert-to', export_filter,
-            '--outdir', workdir, src_file,
-            timeout:,
-            kill_after: timeout * 2
+              Libis::Format::Config[:soffice_cmd], '--headless',
+              "-env:UserInstallation=file://#{workdir}",
+              '--convert-to', export_filter,
+              '--outdir', workdir, src_file,
+              timeout: timeout,
+              kill_after: timeout * 2
           )
 
-          raise "#{self.class} took too long (> #{timeout} seconds) to complete" if result[:timeout]
-
+          raise RuntimeError, "#{self.class} took too long (> #{timeout} seconds) to complete" if result[:timeout]
           warn "OfficeToPdf conversion messages: \n\t#{result[:err].join("\n\t")}" unless result[:err].empty?
-          raise "#{self.class} failed to generate target file #{tgt_file}" unless File.exist?(tgt_file)
+          raise RuntimeError, "#{self.class} failed to generate target file #{tgt_file}" unless File.exist?(tgt_file)
 
           FileUtils.copy tgt_file, target, preserve: true
 
-          {
-            command: result,
-            files: [target]
-          }
         ensure
-          begin
-            FileUtils.rmtree workdir
-          rescue StandardError
-            nil
-          end
+          FileUtils.rmtree workdir rescue nil
+
+          result[:out]
         end
       end
+
     end
   end
 end

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

@@ -0,0 +1,47 @@
+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.run(source, target, options = [])
+          self.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: timeout,
+              kill_after: timeout * 2
+          )
+
+          raise RuntimeError, "#{self.class} took too long (> #{timeout} seconds) to complete" if result[:timeout]
+          raise RuntimeError, "#{self.class} errors: #{result[:err].join("\n")}" unless result[:status] == 0 && result[:err].empty?
+
+          result
+        end
+      end
+
+    end
+  end
+end

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

@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 require 'os'
 
 require 'libis/tools/extend/string'
@@ -11,44 +9,40 @@ require 'libis/format/config'
 module Libis
   module Format
     module Tool
+
       class PdfMerge
         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
+        def self.run(source, target, options = [])
+          self.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_tool]
-          args = [
-            Libis::Format::Config[:java_cmd],
-            '-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]
+          timeout = Libis::Format::Config[:timeouts][:pdf_merge]
+          result = Libis::Tools::Command.run(
+              Libis::Format::Config[:java_cmd],
+              '-cp', Libis::Format::Config[:pdf_tool],
+              'MergePdf',
+              '--file_output', target,
+              *options,
+              *source,
+              timeout: timeout,
+              kill_after: timeout * 2
+          )
+
+          raise RuntimeError, "#{self.class} took too long (> #{timeout} seconds) to complete" if result[:timeout]
+          raise RuntimeError, "#{self.class} errors: #{result[:err].join("\n")}" unless result[:status] == 0 && result[:err].empty?
 
           result
         end
       end
+
     end
   end
 end

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

@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 require 'os'
 
 require 'libis/tools/extend/string'
@@ -11,38 +9,37 @@ require 'libis/format/config'
 module Libis
   module Format
     module Tool
+
       class PdfOptimizer
         include ::Libis::Tools::Logger
 
-        def self.installed?
-          result = Libis::Tools::Command.run(Libis::Format::Config[:ghostscript_cmd], '--version')
-          (result[:status]).zero?
-        end
-
         def self.run(source, target, quality)
-          new.run source, target, quality
+          self.new.run source, target, quality
         end
 
         def run(source, target, quality)
-          timeout = Libis::Format::Config[:timeouts][:pdf_optimizer]
-          args = [
-            Libis::Format::Config[:ghostscript_cmd],
-            '-sDEVICE=pdfwrite',
-            '-dCompatibilityLevel=1.4',
-            "-dPDFSETTINGS=/#{quality}",
-            '-dNOPAUSE',
-            '-dBATCH',
-            "-sOutputFile=#{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]
+          timeout = Libis::Format::Config[:timeouts][:pdf_optimizer]
+          result = Libis::Tools::Command.run(
+              'gs',
+              '-sDEVICE=pdfwrite',
+              '-dCompatibilityLevel=1.4',
+              "-dPDFSETTINGS=/#{quality}",
+              '-dNOPAUSE',
+              '-dBATCH',
+              "-sOutputFile=#{target}",
+              "#{source}",
+              timeout: timeout,
+              kill_after: timeout * 2
+          )
+
+          raise RuntimeError, "#{self.class} took too long (> #{timeout} seconds) to complete" if result[:timeout]
+          raise RuntimeError, "#{self.class} errors: #{result[:err].join("\n")}" unless result[:status] == 0
 
           result
         end
       end
+
     end
   end
 end

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

@@ -1,20 +1,47 @@
-# frozen_string_literal: true
+require 'os'
 
-require 'libis/format/tool/pdf_tool'
+require 'libis/tools/extend/string'
+require 'libis/tools/logger'
+require 'libis/tools/command'
+
+require 'libis/format/config'
 
 module Libis
   module Format
     module Tool
+
       class PdfSplit
+        include ::Libis::Tools::Logger
 
-        def self.run(source, target, *options)
-          PdfTool.run('split', source, target, *options)
+        def self.run(source, target, options = [])
+          self.new.run source, target, options
         end
 
-        def run(source, target, *options)
-          PdfTool.run('split', source, target, *options)
+        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_split]
+          result = Libis::Tools::Command.run(
+              Libis::Format::Config[:java_cmd],
+              '-cp', Libis::Format::Config[:pdf_tool],
+              'SplitPdf',
+              '--file_input', source,
+              '--file_output', target,
+              *options,
+              timeout: timeout,
+              kill_after: timeout * 2
+          )
+
+          raise RuntimeError, "#{self.class} took too long (> #{timeout} seconds) to complete" if result[:timeout]
+          raise RuntimeError, "#{self.class} errors: #{result[:err].join("\n")}" unless result[:status] == 0 && result[:err].empty?
+
+          result
         end
       end
+
     end
   end
 end

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

@@ -1,9 +1,6 @@
-# frozen_string_literal: true
-
 require 'tempfile'
 require 'csv'
 require 'fileutils'
-require 'pdfinfo'
 
 require 'libis/tools/extend/string'
 require 'libis/tools/logger'
@@ -15,24 +12,19 @@ require 'libis/format'
 module Libis
   module Format
     module Tool
+
       class PdfToPdfa
         include ::Libis::Tools::Logger
 
-        def self.installed?
-          result = Libis::Tools::Command.run(Libis::Format::Config[:ghostscript_cmd])
-          result.zero?
+        def self.run(source, target = nil, options = {})
+          self.new.run source, target, options
         end
 
-        def self.run(source, target = nil, **options)
-          new.run source, target, **options
-        end
+        def run(source, target = nil, options = nil)
 
-        def run(source, target = nil, **options)
           tmp_target = Tools::TempFile.name(File.basename(source, '.*'), '.pdf')
           target ||= tmp_target
 
-          metadata = get_metadata(source)
-
           icc_info = icc_options(options[:colorspace])
 
           icc_file = Tools::TempFile.name(icc_info[:icc_name], '.icc')
@@ -40,58 +32,52 @@ module Libis
 
           def_filename = Tools::TempFile.name('PDFA_def', '.ps')
           File.open(def_filename, 'w') do |f|
-            f.puts File.read(File.join(Libis::Format::DATA_DIR, 'PDFA_def.ps'))
-                       .gsub('[**ICC profile**]', icc_file)
-                       .gsub('[**ICC reference**]', icc_info[:icc_ref])
-                       .gsub('[**METADATA**]', metadata)
+            f.puts File.read(File.join(Libis::Format::DATA_DIR, 'PDFA_def.ps')).
+                gsub('[** Fill in ICC profile location **]', icc_file).
+                gsub('[** Fill in ICC reference name **]', icc_info[:icc_ref])
           end
 
           timeout = Libis::Format::Config[:timeouts][:pdf_to_pdfa]
           result = Libis::Tools::Command.run(
-            Libis::Format::Config[:ghostscript_cmd],
-            '-q',
-            '-dBATCH', '-dNOPAUSE', '-dNOOUTERSAVE', '-dNOSAFER',
-            # "-dNOPLATFONTS", "-dUseCIEColor=true",
-            # "-sColorConversionStrategy=/UseDeviceIndependentColor",
-            "-sProcessColorModel=#{icc_info[:device]}",
-            "-sOutputICCProfile=#{icc_file}",
-            '-dCompatibilityLevel=1.4',
-            '-sDEVICE=pdfwrite', '-dPDFA=1', '-dPDFACompatibilityPolicy=1',
-            '-o', File.absolute_path(target),
-            def_filename,
-            source,
-            timeout:,
-            kill_after: timeout * 2
+              Libis::Format::Config[:ghostscript_cmd],
+              '-dBATCH', '-dNOPAUSE', '-dNOOUTERSAVE',
+              '-sColorConversionStrategy=/UseDeviceIndependentColor',
+              "-sProcessColorModel=#{icc_info[:device]}",
+              '-sDEVICE=pdfwrite', '-dPDFA', '-dPDFACompatibilityPolicy=1',
+              "-sOutputICCProfile=#{icc_file}",
+              '-o', File.absolute_path(target),
+              def_filename,
+              source,
+              timeout: timeout,
+              kill_after: timeout * 2
           )
 
-          result[:err] << "#{self.class} took too long (> #{timeout} seconds) to complete" if result[:timeout]
+          raise RuntimeError, "#{self.class} took too long (> #{timeout} seconds) to complete" if result[:timeout]
 
           FileUtils.rm [icc_file, def_filename].compact, force: true
 
+          unless Format::Tool::PdfaValidator.run(target)
+            result[:status] = -999
+            result[:err] << 'Failed to validate generated PDF/A file.'
+          end
+
           result
         end
 
-        private
 
-        def get_metadata(source)
-          info = Pdfinfo.new(source)
-          metadata = "/Title (#{info.title})"
-          metadata += "\n  /Author (#{info.author})" if info.author
-          metadata += "\n  /Subject (#{info.subject})" if info.subject
-          metadata += "\n  /Keywords (#{info.keywords})" if info.keywords
-          metadata += "\n  /Creator (#{info.creator})" if info.creator
-          metadata
-        end
+        private
 
         def icc_options(colorspace)
           case colorspace.to_s.downcase
-          when 'cmyk'
-            { icc_name: 'ISOcoated_v2_eci', icc_ref: 'FOGRA39L', device: 'DeviceCMYK' }
-          else
-            { icc_name: 'AdobeRGB1998', icc_ref: 'sRGB', device: 'DeviceRGB' }
+            when 'cmyk'
+              {icc_name: 'ISOcoated_v2_eci', icc_ref: 'FOGRA39L', device: 'DeviceCMYK'}
+            else
+              {icc_name: 'eciRGB_v2', icc_ref: 'sRGB', device: 'DeviceRGB'}
           end
         end
+
       end
+
     end
   end
 end