libis-format 1.2.8 → 1.3.0

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

@@ -1,4 +1,6 @@
-require_relative "base"
+# frozen_string_literal: true
+
+require_relative 'base'
 
 module Libis
   module Format
@@ -9,10 +11,9 @@ module Libis
         end
 
         def self.output_types(format = nil)
-          if format
-            return [] unless input_types.include?(format)
-          end
-          [:XML, :HTML, :TXT]
+          return [] if format && !input_types.include?(format)
+
+          %i[XML HTML TXT]
         end
 
         def xsl_file(file_path)
@@ -28,20 +29,20 @@ module Libis
           end
 
           unless @options[:xsl_file]
-            error "No xsl_file supplied"
+            error 'No xsl_file supplied'
             return nil
           end
 
           FileUtils.mkpath(File.dirname(target))
 
-          if RUBY_PLATFORM == "java"
-            require "saxon-xslt"
+          if RUBY_PLATFORM == 'java'
+            require 'saxon-xslt'
             xsl = Saxon.XSLT(File.open(@options[:xsl_file]))
             xml = Saxon.XML(File.open(source))
             result = xsl.transform(xml)
             File.write(target, result.to_s)
           else
-            require "nokogiri"
+            require 'nokogiri'
 
             doc = nil
             begin
@@ -65,7 +66,7 @@ module Libis
             xsl = nil
 
             begin
-              fp = File.open(file, "r")
+              fp = File.open(file, 'r')
               xsl = Nokogiri::XSLT(fp) do |config|
                 config.options = Nokogiri::XML::ParseOptions::STRICT | Nokogiri::XML::ParseOptions::NOBLANKS
               end
@@ -80,17 +81,17 @@ module Libis
 
             begin
               target_xml = xsl.transform(doc)
-              fp = File.open(target, "w")
+              fp = File.open(target, 'w')
               fp.write(target_xml)
             rescue Exception => e
               error "Error transforming '#{source}' with '#{file}': #{e.message} @ #{e.backtrace[0]}"
               return nil
             ensure
-              fp.close unless fp.nil? or fp.closed?
+              fp.close unless fp.nil? || fp.closed?
             end
 
             {
-              command: {status: 0},
+              command: { status: 0 },
               files: [target]
             }
 

data/lib/libis/format/converter.rb

@@ -1,4 +1,4 @@
-# code utf-8
+# frozen_string_literal: true
 
 module Libis
   module Format

data/lib/libis/format/identifier.rb

@@ -1,4 +1,4 @@
-# encoding: utf-8
+# frozen_string_literal: true
 
 require 'singleton'
 require 'pathname'
@@ -7,7 +7,6 @@ require 'libis-tools'
 require 'libis/tools/extend/hash'
 require 'libis/tools/extend/string'
 require 'libis/tools/extend/empty'
-require 'nori/core_ext/object'
 
 require 'libis/format/type_database'
 
@@ -19,13 +18,10 @@ require_relative 'tool/extension_identification'
 
 module Libis
   module Format
-
     class Identifier
       include ::Libis::Tools::Logger
       include Singleton
 
-      public
-
       def self.add_xml_validation(mimetype, xsd_file)
         instance.xml_validations[mimetype] = xsd_file
       end
@@ -41,29 +37,28 @@ module Libis
       attr_reader :xml_validations
 
       def get(file, options = {})
-
-        options[:droid] = true unless options.keys.include?(:droid) or (options[:tool] and options[:tool] != :droid)
-        options[:fido] = true unless options.keys.include?(:fido) or (options[:tool] and options[:tool] != :fido)
-        options[:file] = true unless options.keys.include?(:file) or (options[:tool] and options[:tool] != :file)
+        options[:droid] = true unless options.keys.include?(:droid) || (options[:tool] && (options[:tool] != :droid))
+        options[:fido] = true unless options.keys.include?(:fido) || (options[:tool] && (options[:tool] != :fido))
+        options[:file] = true unless options.keys.include?(:file) || (options[:tool] && (options[:tool] != :file))
         options[:xml_validation] = true if options[:xml_validation].nil?
 
-        result = {messages: [], output: {}, formats: {}}
+        result = { messages: [], output: {}, formats: {} }
 
         begin
           get_droid_identification(file, result, options) if options[:droid]
-        rescue => e
+        rescue StandardError => e
           log_msg(result, :error, "Error running Droid: #{e.message} @ #{e.backtrace.first}")
         end
 
         begin
           get_fido_identification(file, result, options) if options[:fido]
-        rescue => e
+        rescue StandardError => e
           log_msg(result, :error, "Error running Fido: #{e.message} @ #{e.backtrace.first}")
         end
 
         begin
           get_file_identification(file, result, options) if options[:file]
-        rescue => e
+        rescue StandardError => e
           log_msg(result, :error, "Error running File: #{e.message} @ #{e.backtrace.first}")
         end
 
@@ -74,14 +69,13 @@ module Libis
         # Libis::Tools::Format::Identifier.add_xml_validation('my_type', '/path/to/my_type.xsd')
         begin
           validate_against_xml_schema(result, options[:base_dir]) if options[:xml_validation]
-        rescue => e
+        rescue StandardError => e
           log_msg(result, :error, "Error validating XML files: #{e.message} @ #{e.backtrace.first}")
         end
 
         process_results(result, !options[:keep_output])
 
         result
-
       end
 
       protected
@@ -123,18 +117,21 @@ module Libis
       end
 
       def xml_validate(file, file_result, result, base_dir)
-        return unless file_result[:mimetype] =~ /^(text|application)\/xml$/
+        return unless file_result[:mimetype] =~ %r{^(text|application)/xml$}
+
         filepath = base_dir ? File.join(base_dir, file) : file
         doc = ::Libis::Tools::XmlDocument.open filepath
         xml_validations.each do |mime, xsd_file|
           next unless xsd_file
+
           begin
             if doc.validates_against?(xsd_file)
               log_msg result, :debug, "XML file validated against XML Schema: #{xsd_file}"
-              info = {mimetype: mime, tool_raw: file_result[:tool], tool: :xsd_validation, match_type: 'xsd_validation', format_version: '', }
+              info = { mimetype: mime, tool_raw: file_result[:tool], tool: :xsd_validation, match_type: 'xsd_validation',
+                       format_version: '' }
               file_result.merge! Libis::Format::TypeDatabase.enrich(info, PUID: :puid, MIME: :mimetype, NAME: :format_name)
             end
-          rescue => e
+          rescue StandardError => e
             # Do nothing - probably Nokogiri chrashed during validation. Could have many causes
             # (remote schema (firewall, network, link rot, ...), schema syntax error, corrupt XML,...)
             # so we log and continue.
@@ -142,7 +139,7 @@ module Libis
                     "Error during XML validation of file #{file} against #{File.basename(xsd_file)}: #{e.message}")
           end
         end
-      rescue => e
+      rescue StandardError => e
         # Not much we can do. probably Nokogiri chrashed opening the XML file. What caused this?
         # (XML not parsable, false XML identification, ???)
         # so we log and continue.
@@ -150,30 +147,30 @@ module Libis
       end
 
       def process_results(result, delete_output = true)
-        result[:output].keys.each do |file|
+        result[:output].each_key do |file|
           output = result[:output][file]
           file_result = result[:formats][file] = {}
           if output.empty?
             log_msg(result, :warn, "Could not identify format of '#{file}'.")
-            file_result = {
-                mimetype: 'application/octet-stream',
-                puid: 'fmt/unknown',
-                score: 0,
-                tool: nil
-            }
+            file_result.merge!(
+              mimetype: 'application/octet-stream',
+              puid: 'fmt/unknown',
+              score: 0,
+              tool: nil
+            )
           else
-            format_matches = output.group_by {|x| [x[:mimetype], x[:puid]]}
+            format_matches = output.group_by { |x| [x[:mimetype], x[:puid]] }
             format_matches.each do |match, group|
-              format_matches[match] = group.group_by {|x| x[:score]}.sort.reverse.to_h
+              format_matches[match] = group.group_by { |x| x[:score] }.sort.reverse.to_h
             end
             case format_matches.count
-              when 0
-                # No this really cannot happen. If there are no hits, there will be at least a format [nil,nil]
-              when 1
-                # only one match, that's easy. The first of the highest score will be used
-                file_result.merge!(get_best_result(output))
-              else
-                process_multiple_formats(file_result, format_matches, output)
+            when 0
+              # No this really cannot happen. If there are no hits, there will be at least a format [nil,nil]
+            when 1
+              # only one match, that's easy. The first of the highest score will be used
+              file_result.merge!(get_best_result(output))
+            else
+              process_multiple_formats(file_result, format_matches, output)
             end
           end
         end
@@ -184,12 +181,13 @@ module Libis
         # multiple matches. Let's select the highest score matches
         file_result.merge!(get_best_result(output))
         file_result[:alternatives] = []
-        format_matches.keys.each do |mime, puid|
+        format_matches.each_key do |mime, puid|
           next if file_result[:mimetype] == mime && puid.nil?
-          selection = output.select {|x| x[:mimetype] == mime && x[:puid] == puid}
+
+          selection = output.select { |x| x[:mimetype] == mime && x[:puid] == puid }
           file_result[:alternatives] << get_best_result(selection)
         end
-        file_result[:alternatives] = file_result[:alternatives].sort_by {|x| x[:score]}.reverse
+        file_result[:alternatives] = file_result[:alternatives].sort_by { |x| x[:score] }.reverse
         file_result.delete(:alternatives) if file_result[:alternatives].size <= 1
       end
 
@@ -208,15 +206,15 @@ module Libis
       end
 
       def get_mimetype(puid)
-        ::Libis::Format::TypeDatabase.puid_typeinfo(puid)[:MIME].first rescue nil
+        ::Libis::Format::TypeDatabase.puid_typeinfo(puid)[:MIME].first
+      rescue StandardError
+        nil
       end
 
       def get_best_result(results)
-        score = results.map {|x| x[:score]}.max
-        results.select {|x| x[:score] == score}.reduce(:apply_defaults)
+        score = results.map { |x| x[:score] }.max
+        results.select { |x| x[:score] == score }.reduce(:apply_defaults)
       end
-
     end
-
   end
 end

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'singleton'
 
 require 'tempfile'
@@ -5,10 +7,10 @@ require 'csv'
 
 require 'libis/format/config'
 
-unless CSV::HeaderConverters.has_key?(:droid_headers)
-  CSV::HeaderConverters[:droid_headers] = lambda {|h|
-    h.encode(ConverterEncoding).downcase.strip.
-        gsub(/\W+/, "").to_sym
+unless CSV::HeaderConverters.key?(:droid_headers)
+  CSV::HeaderConverters[:droid_headers] = lambda { |h|
+    h.encode(ConverterEncoding).downcase.strip
+     .gsub(/\W+/, '').to_sym
   }
 end
 
@@ -17,9 +19,7 @@ require_relative 'identification_tool'
 module Libis
   module Format
     module Tool
-
       class Droid < Libis::Format::Tool::IdentificationTool
-
         def run_list(filelist, _options = {})
           runner(filelist)
         end
@@ -43,12 +43,13 @@ module Libis
         end
 
         def parse_report(report)
-          keys = [
-              :id, :parent_id, :uri, :filepath, :filename, :matchtype, :status, :filesize, :type, :extension,
-              :mod_time, :ext_mismatch, :hash, :format_count, :puid, :mimetype, :format_name, :format_version]
+          keys = %i[
+            id parent_id uri filepath filename matchtype status filesize type extension
+            mod_time ext_mismatch hash format_count puid mimetype format_name format_version
+          ]
           result = CSV.parse(File.readlines(report).join)
-                       .map {|a| Hash[keys.zip(a)]}
-                       .select {|a| a[:type] == 'File'}
+                      .map { |a| Hash[keys.zip(a)] }
+                      .select { |a| a[:type] == 'File' }
           # File.delete report
           result.each do |r|
             r.delete(:id)
@@ -70,39 +71,39 @@ module Libis
 
         def create_report(profile, report)
           args = [
-              '-e', report,
-              '-p', profile,
-              '-q'
+            '-e', report,
+            '-p', profile,
+            '-q'
           ]
           timeout = Libis::Format::Config[:timeouts][:droid]
           result = Libis::Tools::Command.run(
-              Libis::Format::Config[:droid_cmd], *args,
-              timeout: timeout,
-              kill_after: timeout * 2
+            Libis::Format::Config[:droid_cmd], *args,
+            timeout:,
+            kill_after: timeout * 2
           )
-          result[:err].select! {|x| x =~ /^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2},\d{3} ERROR /}
-          raise RuntimeError, "#{self.class} report took too long (> #{timeout} seconds) to complete" if result[:timeout]
-          raise RuntimeError, "#{self.class} report errors: #{result[:err].join("\n")}" unless result[:err].empty?
+          result[:err].select! { |x| x =~ /^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2},\d{3} ERROR / }
+          raise "#{self.class} report took too long (> #{timeout} seconds) to complete" if result[:timeout]
+          raise "#{self.class} report errors: #{result[:err].join("\n")}" unless result[:err].empty?
 
           File.delete profile
         end
 
         def create_profile(file_or_list, profile, recursive = false)
           args = []
-          files = (file_or_list.is_a?(Array)) ? file_or_list.map(&:escape_for_string) : [file_or_list.escape_for_string]
-          files.each {|file| args << '-a' << file}
+          files = file_or_list.is_a?(Array) ? file_or_list.map(&:escape_for_string) : [file_or_list.escape_for_string]
+          files.each { |file| args << '-a' << file }
           args << '-q'
           args << '-p' << profile
           args << '-R' if recursive
           timeout = Libis::Format::Config[:timeouts][:droid]
           result = Libis::Tools::Command.run(
-              Libis::Format::Config[:droid_cmd], *args,
-              timeout: timeout,
-              kill_after: timeout * 2
+            Libis::Format::Config[:droid_cmd], *args,
+            timeout:,
+            kill_after: timeout * 2
           )
-          result[:err].select! {|x| x =~ /^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2},\d{3} ERROR /}
-          raise RuntimeError, "#{self.class} profile took too long (> #{timeout} seconds) to complete" if result[:timeout]
-          raise RuntimeError, "#{self.class} profile errors: #{result[:err].join("\n")}" unless result[:err].empty?
+          result[:err].select! { |x| x =~ /^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2},\d{3} ERROR / }
+          raise "#{self.class} profile took too long (> #{timeout} seconds) to complete" if result[:timeout]
+          raise "#{self.class} profile errors: #{result[:err].join("\n")}" unless result[:err].empty?
         end
 
         def profile_file_name
@@ -112,9 +113,7 @@ module Libis
         def result_file_name
           Tools::TempFile.name('droid', '.csv')
         end
-
       end
-
     end
   end
 end

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'libis/tools/extend/string'
 require 'libis/tools/extend/empty'
 require 'libis/tools/command'
@@ -8,18 +10,17 @@ require 'libis/format/config'
 module Libis
   module Format
     module Tool
-
       class FFMpeg
         include Singleton
         include ::Libis::Tools::Logger
 
         def self.installed?
-          result = Libis::Tools::Command.run(Libis::Format::Config[:ffmpeg_cmd], "-h")
-          result[:status] == 0
+          result = Libis::Tools::Command.run(Libis::Format::Config[:ffmpeg_cmd], '-h')
+          (result[:status]).zero?
         end
 
         def self.run(source, target, options = {})
-          self.instance.run source, target, options
+          instance.run source, target, options
         end
 
         def run(source, target, options = {})
@@ -33,25 +34,22 @@ module Libis
 
           timeout = Libis::Format::Config[:timeouts][:ffmpeg]
           result = Libis::Tools::Command.run(
-              Libis::Format::Config[:ffmpeg_cmd], *opts,
-              timeout: timeout,
-              kill_after: timeout * 2
+            Libis::Format::Config[:ffmpeg_cmd], *opts,
+            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
+          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?
 
           warn "FFMpeg warnings: #{(result[:err] + result[:out]).join("\n")}" unless result[:err].empty?
 
           {
             command: result,
-            files: [ target ]
+            files: [target]
           }
-
         end
-
       end
-
     end
   end
 end

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

@@ -80,7 +80,7 @@ module Libis
 
           # 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 "#{self.class} errors: #{result[:err].join("\n")}" unless (result[:status])&.zero? && 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]

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'os'
 
 require 'libis/tools/extend/string'
@@ -9,49 +11,46 @@ 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] == 0
+          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 = [])
-          self.new.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: timeout,
-              kill_after: timeout * 2
+            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 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?
+          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 ]
+            files: [target]
           }
-
         end
       end
-
     end
   end
 end

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'os'
 
 require 'libis/tools/extend/string'
@@ -9,18 +11,18 @@ 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] == 0
+          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 = [])
-          self.new.run source, target, options
+          new.run source, target, options
         end
 
         def run(source, target, options = [])
@@ -32,27 +34,25 @@ module Libis
 
           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
+            Libis::Format::Config[:java_cmd],
+            '-cp', Libis::Format::Config[:pdf_tool],
+            'MergePdf',
+            '--file_output', target,
+            *options,
+            *source,
+            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?
+          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 ]
+            files: [target]
           }
-
         end
       end
-
     end
   end
 end