libis-format 1.2.1 → 2.0.0

data/lib/libis/format/library.rb

@@ -0,0 +1,147 @@
+# froze_string_litteral: true
+# coding: utf-8
+require 'singleton'
+
+module Libis
+  module Format
+
+    class Library
+      include Singleton
+
+      class << self
+        def implementation=(impl)
+          instance.implementation = impl
+        end
+
+        def get_info(format)
+          instance.get_info(format)
+        end
+
+        def get_info_by(key, value)
+          instance.get_info_by(key, value)
+        end
+
+        def get_infos_by(key, value)
+          instance.get_infos_by(key, value)
+        end
+
+        def get_field(format, field)
+          instance.get_field(format, field)
+        end
+
+        def get_field_by(key, value, field)
+          instance.get_field_by(key, value, field)
+        end
+
+        def get_fields_by(key, value, field)
+          instance.get_fields_by(key, value, field)
+        end
+
+        def known?(key, value)
+          instance.known?(key, value)
+        end
+
+        def enrich(info, map_keys = {})
+          instance.enrich(info, map_keys)
+        end
+
+        def normalize(info, map_keys = {})
+          instance.normalize(info, map_keys)
+        end
+      end
+
+      def implementation=(impl)
+        @implementation = impl
+      end
+
+      def get_field(format, field)
+        get_field_by(:name, format, field)
+      end
+
+      def get_field_by(key, value, field)
+        info = get_info_by(key, value)
+        return nil unless info
+        case field
+        when :mimetype
+          info[:mimetypes]&.first
+        when :puid
+          info[:puids]&.first
+        when :extension
+          info[:extensions]&.first
+        else
+          info[field]
+        end
+      end
+
+      def get_fields_by(key, value, field)
+        get_infos_by(key, value)&.map { |info| info[field] }.compact
+      end
+
+      def get_info(format)
+        get_info_by(:name, format)
+      end
+
+      def get_info_by(key, value)
+        get_infos_by(key, value)&.first
+      end
+
+      def get_infos_by(key, value)
+        result = @implementation.query(key, value)
+        result.map(&:to_hash)
+      end
+
+      def known?(key, value)
+        !get_info_by(key, value).nil?
+      end
+
+      def enrich(info, map_keys = {})
+        info = normalize(info, map_keys)
+        mapper = Hash.new { |hash, key| hash[key] = key }.merge(map_keys)
+        unless (format = info[mapper[:name]]).nil?
+          lib_info = get_info(format)
+          mapper.keys.each do |key|
+            case key
+            when :mimetype
+              info[mapper[key]] = lib_info[:mimetypes].first if lib_info[:mimetypes].first
+            when :puid
+              info[mapper[key]] = lib_info[:puids].first if lib_info[:puids].first
+            when :extension
+              info[mapper[key]] = lib_info[:extensions].first if lib_info[:extensions].first
+            else
+              info[mapper[key]] = lib_info[key] if lib_info[key]
+            end
+          end
+        end
+        info
+      end
+
+      # Derive name from the available info
+      def normalize(info, map_keys = {})
+        return {} unless info.is_a? Hash
+        mapper = Hash.new { |hash, key| hash[key] = key }.merge(map_keys)
+        # fill format from looking up by puid
+        unless (puid = info[mapper[:puid]]).blank?
+          info[mapper[:name]] ||= get_field_by(:puid, puid, :name)
+        end
+        # fill format from looking up by mimetype
+        unless (mime = info[mapper[:mimetype]]).blank?
+          info[mapper[:name]] ||= get_field_by(:mimetype, mime, :name)
+        end
+        # finally complete the information from looking up by format name
+        unless (format = info[mapper[:name]]).nil?
+          info[mapper[:mimetype]] = get_field(format, :mimetype)
+          info[mapper[:category]] = get_field(format, :category)
+        end
+        info
+      end
+
+      private
+
+      def initialize
+        @implementation = eval(Libis::Format::Config[:format_library_implementation])
+      end
+
+    end
+
+  end
+end

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

@@ -37,14 +37,14 @@ module Libis
         def runner(*args)
 
           args.map do |file|
-            info = ::Libis::Format::TypeDatabase.ext_infos(File.extname(file)).first
+            info = ::Libis::Format::Library.get_info_by(:extension, File.extname(file))
             if info
               {
                   filepath: file,
-                  mimetype: (info[:MIME].first rescue nil),
-                  puid: (info[:PUID].first rescue nil),
+                  mimetype: (info[:mimetypes].first rescue nil),
+                  puid: (info[:puids].first rescue nil),
                   matchtype: 'extension',
-                  tool: :type_database
+                  tool: :format_library
               }
             end
           end.cleanup

data/lib/libis/format/tool/{ff_mpeg.rb → ffmpeg.rb}

@@ -13,11 +13,6 @@ module Libis
         include Singleton
         include ::Libis::Tools::Logger
 
-        def self.installed?
-          result = Libis::Tools::Command.run(Libis::Format::Config[:ffmpeg_cmd], "-h")
-          result[:status] == 0
-        end
-
         def self.run(source, target, options = {})
           self.instance.run source, target, options
         end
@@ -43,11 +38,7 @@ module Libis
 
           warn "FFMpeg warnings: #{(result[:err] + result[:out]).join("\n")}" unless result[:err].empty?
 
-          {
-            command: result,
-            files: [ target ]
-          }
-
+          result[:out]
         end
 
       end

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

@@ -13,12 +13,6 @@ module Libis
       class FopPdf
         include ::Libis::Tools::Logger
 
-        def self.installed?
-          result = Libis::Tools::Command.run(Libis::Format::Config[:java_cmd], "-version")
-          return false unless result[:status] == 0
-          File.exist?(Libis::Format::Config[:fop_jar])
-        end
-
         def self.run(xml, target, options = [])
           self.new.run xml, target, options
         end
@@ -33,7 +27,6 @@ module Libis
           result = Libis::Tools::Command.run(
               Libis::Format::Config[:java_cmd],
               "-Dfop.home=#{File.dirname(Libis::Format::Config[:fop_jar])}",
-              '-Djava.awt.headless=true',
               '-jar', Libis::Format::Config[:fop_jar],
               '-fo', xml,
               '-pdf', target,
@@ -44,11 +37,6 @@ module Libis
           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
 
-          {
-            command: result,
-            files: [ target ]
-          }
-
         end
       end
 

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

@@ -7,7 +7,7 @@ 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
@@ -99,7 +99,7 @@ module Libis
           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
@@ -117,14 +117,14 @@ module Libis
             # Signature match increases score with 2
             when 'signature'
               result[:score] += 2
-            # typeinfo = ::Libis::Format::TypeDatabase.puid_typeinfo(result[:puid])
+            # 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])
+            # 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)
 
@@ -152,11 +152,11 @@ module Libis
         end
 
         def get_mimetype(puid)
-          ::Libis::Format::TypeDatabase.puid_typeinfo(puid)[:MIME].first rescue 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 nil
+          ::Libis::Format::Library.get_field_by(:mimetype, mimetype, :puid) rescue nil
         end
 
         attr_accessor :bad_mimetypes, :bad_puids

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

@@ -13,11 +13,6 @@ module Libis
       class OfficeToPdf
         include ::Libis::Tools::Logger
 
-        def self.installed?
-          result = Libis::Tools::Command.run(Libis::Format::Config[:soffice_cmd], "--version")
-          result[:status] == 0
-        end
-
         def self.run(source, target, options = {})
           self.new.run source, target, options
         end
@@ -52,14 +47,10 @@ module Libis
 
           FileUtils.copy tgt_file, target, preserve: true
 
-          {
-            command: result,
-            files: [ target ]
-          }
-
         ensure
           FileUtils.rmtree workdir rescue nil
 
+          result[:out]
         end
       end
 

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

@@ -13,12 +13,6 @@ module Libis
       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] == 0
-          File.exist?(Libis::Format::Config[:pdf_tool])
-        end
-
         def self.run(source, target, options = [])
           self.new.run source, target, options
         end
@@ -44,11 +38,7 @@ module Libis
           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?
 
-          {
-            command: result,
-            files: [ target ]
-          }
-
+          result
         end
       end
 

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

@@ -13,12 +13,6 @@ module Libis
       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] == 0
-          File.exist?(Libis::Format::Config[:pdf_tool])
-        end
-
         def self.run(source, target, options = [])
           self.new.run source, target, options
         end
@@ -45,11 +39,7 @@ module Libis
           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?
 
-          {
-            command: result,
-            files: [ target ]
-          }
-
+          result
         end
       end
 

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

@@ -13,11 +13,6 @@ module Libis
       class PdfOptimizer
         include ::Libis::Tools::Logger
 
-        def self.installed?
-          result = Libis::Tools::Command.run(Libis::Format::Config[:ghostscript_cmd], "--version")
-          result[:status] == 0
-        end
-
         def self.run(source, target, quality)
           self.new.run source, target, quality
         end
@@ -26,7 +21,7 @@ module Libis
 
           timeout = Libis::Format::Config[:timeouts][:pdf_optimizer]
           result = Libis::Tools::Command.run(
-              Libis::Format::Config[:ghostscript_cmd],
+              'gs',
               '-sDEVICE=pdfwrite',
               '-dCompatibilityLevel=1.4',
               "-dPDFSETTINGS=/#{quality}",
@@ -41,11 +36,7 @@ module Libis
           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
 
-          {
-            command: result,
-            files: [ target ]
-          }
-
+          result
         end
       end
 

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

@@ -13,12 +13,6 @@ module Libis
       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] == 0
-          File.exist?(Libis::Format::Config[:pdf_tool])
-        end
-
         def self.run(source, target, options = [])
           self.new.run source, target, options
         end
@@ -44,11 +38,7 @@ module Libis
           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?
 
-          {
-            command: result,
-            files: [ target ] # TODO: collect the files
-          }
-
+          result
         end
       end
 

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

@@ -1,99 +1,83 @@
-require "tempfile"
-require "csv"
-require "fileutils"
-require 'pdfinfo'
+require 'tempfile'
+require 'csv'
+require 'fileutils'
 
-require "libis/tools/extend/string"
-require "libis/tools/logger"
-require "libis/tools/command"
-require "libis/tools/temp_file"
+require 'libis/tools/extend/string'
+require 'libis/tools/logger'
+require 'libis/tools/command'
+require 'libis/tools/temp_file'
 
-require "libis/format"
+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 == 0
-        end
-
         def self.run(source, target = nil, options = {})
-          new.run source, target, options
+          self.new.run source, target, options
         end
 
         def run(source, target = nil, options = nil)
-          tmp_target = Tools::TempFile.name(File.basename(source, ".*"), ".pdf")
-          target ||= tmp_target
 
-          metadata = get_metadata(source)
+          tmp_target = Tools::TempFile.name(File.basename(source, '.*'), '.pdf')
+          target ||= tmp_target
 
           icc_info = icc_options(options[:colorspace])
 
-          icc_file = Tools::TempFile.name(icc_info[:icc_name], ".icc")
+          icc_file = Tools::TempFile.name(icc_info[:icc_name], '.icc')
           FileUtils.cp(File.join(Libis::Format::DATA_DIR, "#{icc_info[:icc_name]}.icc"), icc_file)
 
-          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)
+          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('[** 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: 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
           )
 
-          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
+          raise RuntimeError, "#{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]
-          }
+          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
-        
         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

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

@@ -1,22 +1,24 @@
-require "fileutils"
+require 'fileutils'
 
-require "libis/tools/extend/string"
-require "libis/tools/logger"
-require "libis/tools/command"
+require 'libis/tools/extend/string'
+require 'libis/tools/logger'
+require 'libis/tools/command'
 
-require "libis/format/config"
+require 'libis/format/config'
 
 module Libis
   module Format
     module Tool
+
       class PdfaValidator
         include ::Libis::Tools::Logger
 
         def self.run(source)
-          new.run source
+          self.new.run source
         end
 
         def run(source)
+
           src_file = File.absolute_path(source)
 
           timeout = Libis::Format::Config[:timeouts][:pdfa_validator]
@@ -26,41 +28,46 @@ module Libis
             Dir.chdir(Dir.tmpdir)
 
             result = Libis::Tools::Command.run(
-              pdfa,
-              "--noxml",
-              "--level", "B",
-              "--verb", "0",
-              src_file,
-              timeout: timeout,
-              kill_after: timeout * 2
+                pdfa,
+                '--noxml',
+                '--level', 'B',
+                '--verb', '0',
+                src_file,
+                timeout: 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] == 0 && result[:err].empty?
+            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?
 
             Dir.chdir(previous_wd)
 
-            out, err = result[:out].partition { |line| line =~ /^VLD-\[PASS\]/ }
-            result[:out] = out
-            result[:err] += err
-
-            result
+            unless result[:out].any? {|line| line =~ /^VLD-\[PASS\]/}
+              warn "Validator failed to validate the PDF file '%s' against PDF/A-1B constraints:\n%s", source,
+                   result[:out].join("\n")
+              return false
+            end
           else
             jar = Libis::Format::Config[:preflight_jar]
             result = Libis::Tools::Command.run(
-              Libis::Format::Config[:java_cmd],
-              "-jar", jar,
-              src_file,
-              timeout: timeout,
-              kill_after: timeout * 2
+                Libis::Format::Config[:java_cmd],
+                '-jar', jar,
+                src_file,
+                timeout: timeout,
+                kill_after: timeout * 2
             )
+            raise RuntimeError, "#{self.class} took too long (> #{timeout} seconds) to complete" if result[:timeout]
 
-            raise "#{self.class} took too long (> #{timeout} seconds) to complete" if result[:timeout]
-
-            result
+            unless result[:status] == 0
+              warn "Validator failed to validate the PDF file '%s' against PDF/A-1B constraints:\n%s", source,
+                   result[:out].join("\n")
+              return false
+            end
           end
+          true
         end
       end
+
     end
   end
 end