libis-format 1.3.3 → 2.0.0

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

@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 require 'libis/tools/extend/string'
 require 'libis/tools/command'
 
@@ -11,33 +9,36 @@ require_relative 'identification_tool'
 module Libis
   module Format
     module Tool
+
       class Fido < Libis::Format::Tool::IdentificationTool
+
         def self.add_formats(formats_file)
-          instance.formats << formats_file unless instance.formats.include?(formats_file)
+          self.instance.formats << formats_file unless self.instance.formats.include?(formats_file)
         end
 
         def self.del_formats(formats_file)
-          instance.formats.delete(formats_file)
+          self.instance.formats.delete(formats_file)
         end
 
         attr_reader :formats
 
-        def run_list(filelist, **options)
+        def run_list(filelist, options = {})
           create_list_file(filelist) do |list_file|
-            output = runner(nil, '-input', list_file.escape_for_string, **options)
+            output = runner(nil, '-input', list_file.escape_for_string, options)
             process_output(output)
           end
         end
 
-        def run_dir(dir, recursive = true, **options)
+        def run_dir(dir, recursive = true, options = {})
           args = []
           args << '-recurse' if recursive
-          output = runner(dir, *args, **options)
+          args << options
+          output = runner(dir, *args)
           process_output(output)
         end
 
-        def run(file, **options)
-          output = runner(file, **options)
+        def run(file, options = {})
+          output = runner(file, options)
           process_output(output)
         end
 
@@ -52,9 +53,11 @@ module Libis
 
         attr_writer :formats
 
-        def runner(filename, *args, **options)
-          # Load custom format definitions if present
-          args << '-loadformats' << formats.join(',').to_s unless formats.empty?
+        def runner(filename, *args)
+          options = {}
+          options = args.pop if args.last.is_a?(Hash)
+          # Load custome format definitions if present
+          args << '-loadformats' << "#{formats.join(',')}" unless formats.empty?
 
           # Workaround for Fido performance bug
           args << '-bufsize' << (options[:bufsize] || 1000).to_s
@@ -65,7 +68,7 @@ module Libis
           args << '-nocontainer' if options[:nocontainer]
 
           # Add filename to argument list (optional)
-          args << filename.escape_for_string.to_s if filename
+          args << "#{filename.escape_for_string}" if filename
 
           # No header output
           args << '-q'
@@ -73,20 +76,20 @@ module Libis
           # Run command and capture results
           timeout = Libis::Format::Config[:timeouts][:fido]
           result = ::Libis::Tools::Command.run(
-            Libis::Format::Config[:fido_cmd], *args,
-            timeout:,
-            kill_after: timeout * 2
+              Libis::Format::Config[:fido_cmd], *args,
+              timeout: timeout,
+              kill_after: timeout * 2
           )
 
           # Log warning if needed
-          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?
+          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?
 
           # Parse output (CSV) text into array and return result
-          keys = %i[status time puid format_name format_version filesize filepath mimetype matchtype]
+          keys = [:status, :time, :puid, :format_name, :format_version, :filesize, :filepath, :mimetype, :matchtype]
           data = CSV.parse(result[:out].join("\n"))
-                    .map { |a| Hash[keys.zip(a)] }
-                    .select { |a| a[:status] == 'OK' }
+                       .map {|a| Hash[keys.zip(a)]}
+                       .select {|a| a[:status] == 'OK'}
           data.each do |r|
             r.delete(:time)
             r.delete(:status)
@@ -94,7 +97,9 @@ module Libis
             r[:tool] = :fido
           end
         end
+
       end
+
     end
   end
 end

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

@@ -1,38 +1,49 @@
-# frozen_string_literal: true
-
 require_relative 'identification_tool'
 
 module Libis
   module Format
     module Tool
+
       class FileTool < Libis::Format::Tool::IdentificationTool
-        def run_list(filelist, **_options)
+
+        def run_list(filelist, _options = {})
+
           create_list_file(filelist) do |list_file|
+
             output = runner(nil, '--files-from', list_file)
 
             process_output(output)
+
           end
+
         end
 
-        def run_dir(dir, recursive = true, **_options)
+        def run_dir(dir, recursive = true, _options = {})
+
           filelist = find_files(dir, recursive)
 
           create_list_file(filelist) do |list_file|
+
             output = runner(nil, '--files-from', list_file)
 
             process_output(output)
+
           end
+
         end
 
-        def run(file, **_options)
+        def run(file, _options = {})
+
           output = runner(file)
 
           process_output(output)
+
         end
 
         protected
 
         def runner(filename, *args)
+
           # Create new argument list
           opts = []
 
@@ -50,21 +61,23 @@ module Libis
           # Run the UNIX file command and capture the results
           timeout = Libis::Format::Config[:timeouts][:file_tool]
           result = ::Libis::Tools::Command.run(
-            'file', *opts,
-            timeout:,
-            kill_after: timeout * 2
+              'file', *opts,
+              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]).zero? && 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?
 
           # Parse output text into array and return result
           result[:out].map do |line|
             r = line.split(/:\s+/)
-            { filepath: r[0], mimetype: r[1], matchtype: 'magic', tool: :file }
+            {filepath: r[0], mimetype: r[1], matchtype: 'magic', tool: :file}
           end
         end
+
       end
+
     end
   end
 end

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

@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 require 'os'
 
 require 'libis/tools/extend/string'
@@ -11,46 +9,37 @@ require 'libis/format/config'
 module Libis
   module Format
     module Tool
+
       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]).zero?
-
-          File.exist?(Libis::Format::Config[:fop_jar])
+        def self.run(xml, target, options = [])
+          self.new.run xml, target, options
         end
 
-        def self.run(xml, target)
-          new.run xml, target
-        end
+        def run(xml, target, options = [])
 
-        def run(xml, target)
           if OS.java?
             # TODO: import library and execute in current VM. For now do exactly as in MRI.
           end
 
           timeout = Libis::Format::Config[:timeouts][:fop]
           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,
-            timeout:,
-            kill_after: timeout * 2
+              Libis::Format::Config[:java_cmd],
+              "-Dfop.home=#{File.dirname(Libis::Format::Config[:fop_jar])}",
+              '-jar', Libis::Format::Config[:fop_jar],
+              '-fo', xml,
+              '-pdf', target,
+              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]).zero?
+          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
+
     end
   end
 end

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