libis-format 1.2.9 → 1.3.0

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'os'
 
 require 'libis/tools/extend/string'
@@ -9,46 +11,42 @@ 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] == 0
+          result = Libis::Tools::Command.run(Libis::Format::Config[:ghostscript_cmd], '--version')
+          (result[:status]).zero?
         end
 
         def self.run(source, target, quality)
-          self.new.run source, target, quality
+          new.run source, target, quality
         end
 
         def run(source, target, quality)
-
           timeout = Libis::Format::Config[:timeouts][:pdf_optimizer]
           result = Libis::Tools::Command.run(
-              Libis::Format::Config[:ghostscript_cmd],
-              '-sDEVICE=pdfwrite',
-              '-dCompatibilityLevel=1.4',
-              "-dPDFSETTINGS=/#{quality}",
-              '-dNOPAUSE',
-              '-dBATCH',
-              "-sOutputFile=#{target}",
-              "#{source}",
-              timeout: timeout,
-              kill_after: timeout * 2
+            Libis::Format::Config[:ghostscript_cmd],
+            '-sDEVICE=pdfwrite',
+            '-dCompatibilityLevel=1.4',
+            "-dPDFSETTINGS=/#{quality}",
+            '-dNOPAUSE',
+            '-dBATCH',
+            "-sOutputFile=#{target}",
+            source.to_s,
+            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?
 
           {
             command: result,
-            files: [ target ]
+            files: [target]
           }
-
         end
       end
-
     end
   end
 end

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

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

data/lib/libis/format/tool.rb

@@ -1,9 +1,10 @@
+# frozen_string_literal: true
+
 # code utf-8
 
 module Libis
   module Format
     module Tool
-
       autoload :Droid, 'libis/format/tool/droid'
       autoload :ExtensionIdentification, 'libis/format/tool/extension_identification'
       autoload :Fido, 'libis/format/tool/fido'
@@ -19,7 +20,6 @@ module Libis
       autoload :PdfToPdfa, 'libis/format/tool/pdf_to_pdfa'
       autoload :PdfaValidator, 'libis/format/tool/pdfa_validator'
       autoload :MsgToPdf, 'libis/format/tool/msg_to_pdf'
-
     end
   end
 end

data/lib/libis/format/type_database.rb

@@ -1,11 +1,10 @@
-# coding: utf-8
+# frozen_string_literal: true
 
 require 'yaml'
 require 'libis/tools/extend/hash'
 
 module Libis
   module Format
-
     # noinspection RubyClassVariableUsageInspection
     class TypeDatabase
       @implementation = Libis::Format::TypeDatabaseImpl.instance
@@ -16,16 +15,25 @@ module Libis
 
       def self.enrich(info, map_keys = {})
         return {} unless info.is_a? Hash
-        mapper = Hash.new {|hash,key| hash[key] = key}
+
+        mapper = Hash.new { |hash, key| hash[key] = key }
         mapper.merge! map_keys
         unless (puid = info[mapper[:PUID]]).blank?
-          info[mapper[:TYPE]] ||= puid_infos(puid).first[:TYPE] rescue nil
+          info[mapper[:TYPE]] ||= begin
+            puid_infos(puid).first[:TYPE]
+          rescue StandardError
+            nil
+          end
         end
         unless (mime = info[mapper[:MIME]]).blank?
-          info[mapper[:TYPE]] ||= mime_infos(mime).first[:TYPE] rescue nil
+          info[mapper[:TYPE]] ||= begin
+            mime_infos(mime).first[:TYPE]
+          rescue StandardError
+            nil
+          end
         end
         unless (type_name = info[mapper[:TYPE]]).nil?
-          mapper.keys.each do |key|
+          mapper.each_key do |key|
             info[mapper[key]] = get(type_name, key) || info[mapper[key]]
           end
           info[mapper[:GROUP]] = type_group(type_name)
@@ -35,13 +43,22 @@ module Libis
 
       def self.normalize(info, map_keys = {})
         return {} unless info.is_a? Hash
-        mapper = Hash.new {|hash,key| hash[key] = key}
+
+        mapper = Hash.new { |hash, key| hash[key] = key }
         mapper.merge! map_keys
         unless (puid = info[mapper[:PUID]]).blank?
-          info[mapper[:TYPE]] ||= puid_infos(puid).first[:TYPE] rescue nil
+          info[mapper[:TYPE]] ||= begin
+            puid_infos(puid).first[:TYPE]
+          rescue StandardError
+            nil
+          end
         end
         unless (mime = info[mapper[:MIME]]).blank?
-          info[mapper[:TYPE]] ||= mime_infos(mime).first[:TYPE] rescue nil
+          info[mapper[:TYPE]] ||= begin
+            mime_infos(mime).first[:TYPE]
+          rescue StandardError
+            nil
+          end
         end
         unless (type_name = info[mapper[:TYPE]]).nil?
           info[mapper[:MIME]] = type_mimetypes(type_name).first if type_mimetypes(type_name).first
@@ -52,35 +69,35 @@ module Libis
 
       def self.get(type_name, key)
         case key
-          when :MIME
-            type_mimetypes(type_name).first
-          when :PUID
-            type_puids(type_name).first
-          when :EXTENSION
-            type_extentions(type_name).first
-          else
-            typeinfo(type_name)[key]
+        when :MIME
+          type_mimetypes(type_name).first
+        when :PUID
+          type_puids(type_name).first
+        when :EXTENSION
+          type_extentions(type_name).first
+        else
+          typeinfo(type_name)[key]
         end
       end
 
-      def self.type_group(t)
-        typeinfo(t)[:GROUP]
+      def self.type_group(ftype)
+        typeinfo(ftype)[:GROUP]
       end
 
-      def self.type_mimetypes(t)
-        typeinfo(t)[:MIME] || []
+      def self.type_mimetypes(ftype)
+        typeinfo(ftype)[:MIME] || []
       end
 
-      def self.type_puids(t)
-        typeinfo(t)[:PUID] || []
+      def self.type_puids(ftype)
+        typeinfo(ftype)[:PUID] || []
       end
 
-      def self.type_extentions(t)
-        typeinfo(t)[:EXTENSIONS] || []
+      def self.type_extentions(ftype)
+        typeinfo(ftype)[:EXTENSIONS] || []
       end
 
-      def self.typeinfo(t)
-        @implementation.typeinfo(t)
+      def self.typeinfo(ftype)
+        @implementation.typeinfo(ftype)
       end
 
       def self.group_types(group)
@@ -127,7 +144,13 @@ module Libis
         @implementation.known_mime?(mime)
       end
 
-    end
+      def self.groups
+        @implementation.groups
+      end
 
+      def self.export_csv(filename, **options)
+        @implementation.export_csv(filename, **options)
+      end
+    end
   end
 end

data/lib/libis/format/type_database_impl.rb

@@ -1,21 +1,22 @@
-# coding: utf-8
+# frozen_string_literal: true
 
 require 'singleton'
 require 'yaml'
+require 'csv'
 
 require 'libis/tools/logger'
 require 'libis/tools/extend/hash'
 require 'libis/tools/extend/string'
+require 'libis/tools/extend/symbol'
 
 module Libis
   module Format
-
     class TypeDatabaseImpl
       include Singleton
       include ::Libis::Tools::Logger
 
-      def typeinfo(t)
-        @types[t.to_sym] || {}
+      def typeinfo(ftype)
+        @types[ftype.to_sym] || {}
       end
 
       def group_types(group)
@@ -26,58 +27,84 @@ module Libis
 
       def puid_infos(puid)
         @types.select do |_, v|
-          v[:PUID].include? puid rescue false
+          v[:PUID].include? puid
+        rescue StandardError
+          false
         end.values
       end
 
       def puid_types(puid)
         @types.select do |_, v|
-          v[:PUID].include? puid rescue false
+          v[:PUID].include? puid
+        rescue StandardError
+          false
         end.keys
       end
 
       def mime_infos(mime)
         @types.select do |_, v|
-          v[:MIME].include? mime rescue false
+          v[:MIME].include? mime
+        rescue StandardError
+          false
         end.values
       end
 
       def mime_types(mime)
         @types.select do |_, v|
-          v[:MIME].include? mime rescue false
+          v[:MIME].include? mime
+        rescue StandardError
+          false
         end.keys
       end
 
       def ext_infos(ext)
-        ext = ext.gsub /^\./, ''
+        ext = ext.gsub(/^\./, '')
         @types.select do |_, v|
-          v[:EXTENSIONS].include?(ext) rescue false
+          v[:EXTENSIONS].include?(ext)
+        rescue StandardError
+          false
         end.values
       end
 
       def ext_types(ext)
-        ext = ext.gsub /^\./, ''
+        ext = ext.gsub(/^\./, '')
         @types.select do |_, v|
-          v[:EXTENSIONS].include?(ext) rescue false
+          v[:EXTENSIONS].include?(ext)
+        rescue StandardError
+          false
         end.keys
       end
 
       def puid_typeinfo(puid)
         @types.each do |_, v|
-          return v if v[:PUID] and v[:PUID].include?(puid)
+          return v if v[:PUID]&.include?(puid)
         end
         nil
       end
 
       def known_mime?(mime)
         @types.each do |_, v|
-          return true if v[:MIME].include? mime
+          return true if v[:MIME]&.include? mime
         end
         false
       end
 
+      def groups
+        @types.values.map(&:dig.call(:GROUP)).uniq
+      end
+
+      def export_csv(filename, **options)
+        headers = @types.values.each_with_object(Set.new) { |v, s| v.each_key { |k| s << k.to_s } }
+        options[:headers] = headers.to_a
+        CSV.open(filename, 'w', **options) do |csv|
+          @types.each_value do |v|
+            csv << CSV::Row.new(v.keys, v.values.map { |x| x.is_a?(Array) ? x.join(', ') : x })
+          end
+        end
+      end
+
       def load_types(file_or_hash = {}, append = true)
-        hash = file_or_hash.is_a?(Hash) ? file_or_hash : YAML::load_file(file_or_hash)
+        hash = file_or_hash.is_a?(Hash) ? file_or_hash : YAML.load_file(file_or_hash)
         # noinspection RubyResolve
         hash.each do |group, type_info|
           type_info.each do |type_name, info|
@@ -85,12 +112,20 @@ module Libis
             info.symbolize_keys!
             info[:TYPE] = type_key
             info[:GROUP] = group.to_sym
-            info[:MIME] = info[:MIME].strip.split(/[\s,]+/).map(&:strip) rescue []
-            info[:EXTENSIONS] = info[:EXTENSIONS].strip.split(/[\s,]+/).map { |v| v.strip } rescue []
-            info[:PUID] = info[:PUID].strip.split(/[\s,]+/).map { |v| v.strip } if info[:PUID]
-            if @types.has_key?(type_key)
-              warn 'Type %s already defined; merging with info from %s.', type_name.to_s, file_or_hash
-              info.merge!(@types[type_key]) do |_,v_new,v_old|
+            info[:MIME] = begin
+              info[:MIME].strip.split(/[\s,]+/).map(&:strip)
+            rescue StandardError
+              []
+            end
+            info[:EXTENSIONS] = begin
+              info[:EXTENSIONS].strip.split(/[\s,]+/).map(&:strip)
+            rescue StandardError
+              []
+            end
+            info[:PUID] = info[:PUID].strip.split(/[\s,]+/).map(&:strip) if info[:PUID]
+            if @types.key?(type_key)
+              warn 'Type %s already defined; merging with info from %s.', type_name, file_or_hash
+              info.merge!(@types[type_key]) do |_, v_new, v_old|
                 case v_old
                 when Array
                   append ? v_old + v_new : v_new + v_old
@@ -109,12 +144,10 @@ module Libis
       protected
 
       def initialize
-        @types = Hash.new
+        @types = {}
         type_database = Libis::Format::Config[:type_database]
         load_types(type_database)
       end
-
     end
-
   end
 end

data/lib/libis/format/version.rb

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

data/lib/libis/format.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'libis/format/version'
 
 module Libis
@@ -13,6 +15,5 @@ module Libis
     ROOT_DIR = File.absolute_path(File.join(File.dirname(__FILE__), '..', '..'))
     DATA_DIR = File.join(ROOT_DIR, 'data')
     TOOL_DIR = File.join(ROOT_DIR, 'tools')
-
   end
-end
+end

data/lib/libis-format.rb

@@ -1 +1,3 @@
+# frozen_string_literal: true
+
 require 'libis/format'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: libis-format
 version: !ruby/object:Gem::Version
-  version: 1.2.9
+  version: 1.3.0
 platform: ruby
 authors:
 - Kris Dekeyser
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-11-27 00:00:00.000000000 Z
+date: 2024-03-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: chromaprint
@@ -367,7 +367,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.10
+rubygems_version: 3.5.1
 signing_key: 
 specification_version: 4
 summary: LIBIS File format format services.