libis-format 1.2.9 → 2.0.0

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

@@ -0,0 +1,70 @@
+# encoding: utf-8
+
+require_relative 'base'
+
+require 'libis/tools/extend/hash'
+require 'libis/format/tool/pdf_copy'
+require 'libis/format/tool/pdf_to_pdfa'
+require 'libis/format/tool/pdf_optimizer'
+
+module Libis
+  module Format
+    module Converter
+
+      class PdfOptimizer < Libis::Format::Converter::Base
+
+        def self.input_types
+          [:PDF]
+        end
+
+        def self.output_types(format = nil)
+          return [] unless input_types.include?(format) if format
+          [:PDF]
+        end
+
+        def pdf_optimize(_)
+          #force usage of this converter
+        end
+
+        # Optimize the PDF
+        #
+        # This reduces the graphics quality to a level in order to limit file size. This option relies on the
+        # presence of ghostscript and takes one argument: the quality level. It should be one of:
+        #
+        # - 0 : lowest quality (Acrobat Distiller 'Screen Optimized' equivalent)
+        # - 1 : medium quality (Acrobat Distiller 'eBook' equivalent)
+        # - 2 : good quality
+        # - 3 : high quality (Acrobat Distiller 'Print Optimized' equivalent)
+        # - 4 : highest quality (Acrobat Distiller 'Prepress Optimized' equivalent)
+        #
+        # Note that the optimization is intended to be used with PDF's containing high-resolution images.
+        #
+        # @param [Integer] setting quality setting. [0-4]
+        def quality(setting = 1)
+          @quality = %w(screen ebook default printer prepress)[setting] if (0..4) === setting
+        end
+
+        def convert(source, target, format, opts = {})
+          super
+
+           optimize_pdf(source, target, @quality || 'ebook')
+
+        end
+
+        def optimize_pdf(source, target, quality)
+
+          using_temp(target) do |tmpname|
+            result = Libis::Format::Tool::PdfOptimizer.run(source, tmpname, quality)
+            unless result[:status] == 0
+              error("Pdf optimization encountered errors:\n%s", (result[:err] + result[:out]).join("\n"))
+              next nil
+            end
+            tmpname
+          end
+        end
+
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,65 @@
+# encoding: utf-8
+
+require_relative 'base'
+
+require 'libis/format/tool/pdf_split'
+
+module Libis
+  module Format
+    module Converter
+
+      # noinspection DuplicatedCode
+      class PdfSplitter < Libis::Format::Converter::Base
+
+        def self.input_types
+          [:PDF]
+        end
+
+        def self.output_types(format = nil)
+          return [] unless input_types.include?(format) if format
+          [:PDF]
+        end
+
+        def pdf_split(_)
+          #force usage of this converter
+        end
+
+        def self.category
+          :splitter
+        end
+
+        # Split at given page. If omitted or nil, the source PDF will be split at every page
+        def page(v)
+          @page = v unless v.blank
+        end
+
+        def convert(source, target, format, opts = {})
+          super
+
+          result = split(source, target)
+          return nil unless result
+
+          result
+        end
+
+        private
+
+        def split(source, target)
+
+          options = @page ? ['--page', @page] : ['--every_page']
+          using_temp(target) do |tmpname|
+            result = Libis::Format::Tool::PdfSplit.run(source, tmpname, *options)
+            unless result[:err].empty?
+              error("Pdf split encountered errors:\n%s", result[:err].join(join("\n")))
+              next nil
+            end
+            tmpname
+          end
+
+        end
+
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,110 @@
+# encoding: utf-8
+
+require_relative 'base'
+
+require 'libis/tools/extend/hash'
+require 'libis/format/tool/pdf_copy'
+require 'libis/format/tool/pdf_to_pdfa'
+require 'libis/format/tool/pdf_optimizer'
+
+module Libis
+  module Format
+    module Converter
+
+      class PdfWatermarker < Libis::Format::Converter::Base
+
+        def self.input_types
+          [:PDF]
+        end
+
+        def self.output_types(format = nil)
+          return [] unless input_types.include?(format) if format
+          [:PDF]
+        end
+
+        def pdf_watermark(_)
+          #force usage of this converter
+        end
+
+        def initialize
+          super
+          @options[:text] = '© LIBIS'
+          @options[:opacity] = '0.3'
+        end
+
+        def file(v)
+          @options[:file] = v.blank? ? nil : v
+        end
+
+        def text(v)
+          @options[:text] = v
+        end
+
+        def rotation(v)
+          @options[:rotation] = v unless v.blank?
+        end
+
+        def size(v)
+          @options[:size] = v unless v.blank?
+        end
+
+        def opacity(v)
+          @options[:opacity] = v unless v.blank?
+        end
+
+        def gap_size(v)
+          @options[:gap_size] = v
+        end
+
+        def gap_ratio(v)
+          @options[:gap_ratio] = v
+        end
+
+        def convert(source, target, format, opts = {})
+          super
+
+          result = convert_pdf(source, target)
+          return nil unless result
+
+          result
+
+        end
+
+        OPTIONS_TABLE = {
+            file: 'wm_image',
+            text: 'wm_text',
+            rotation: 'wm_text_rotation',
+            size: 'wm_font_size',
+            opacity: 'wm_opacity',
+            gap_size: 'wm_gap_size',
+            gap_ratio: 'wm_gap_ratio'
+        }
+        # noinspection DuplicatedCode
+        def convert_pdf(source, target)
+
+          using_temp(target) do |tmpname|
+            result = Libis::Format::Tool::PdfCopy.run(
+                source, tmpname,
+                @options.map {|k, v|
+                  if v.nil?
+                    nil
+                  else
+                    v = v.split('\n') unless v.blank? if k == :text
+                    k = OPTIONS_TABLE[k] || k
+                    ["--#{k}", (v.is_a?(Array) ? v : v.to_s)]
+                  end}.compact.flatten
+            )
+            unless result[:err].empty?
+              error("Pdf conversion encountered errors:\n%s", result[:err].join(join("\n")))
+              next nil
+            end
+            tmpname
+          end
+
+        end
+
+      end
+
+    end
+  end
+end

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

@@ -3,7 +3,7 @@
 require_relative 'base'
 
 require 'libis/format/tool/spreadsheet_to_ods'
-require 'libis/format/type_database'
+require 'libis/format/library'
 
 module Libis
   module Format
@@ -20,7 +20,7 @@ module Libis
         end
 
         def self.output_types(format = nil)
-          return [] unless input_types.include?(format)
+          return [] unless input_types.include?(format) if format
           [:OO_CALC]
         end
 
@@ -31,7 +31,9 @@ module Libis
         def convert(source, target, format, opts = {})
           super
 
-          Format::Tool::SpreadsheetToOds.run(source, target)
+          return nil unless Format::Tool::SpreadsheetToOds.run(source, target)
+
+          target
 
         end
 

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

@@ -1,5 +1,5 @@
 require_relative 'base'
-require 'libis/format/tool/ff_mpeg'
+require 'libis/format/tool/ffmpeg'
 
 require 'fileutils'
 
@@ -14,7 +14,7 @@ module Libis
         end
 
         def self.output_types(format = nil)
-          return [] unless input_types.include?(format)
+          return [] unless input_types.include?(format) if format
           [:GIF, :WEBM, :MP4, :MPG, :MKV, :MJP2, :QTFF, :AVI, :OGGV, :WMV, :DV, :FLV, :SWF]
         end
 
@@ -179,10 +179,7 @@ module Libis
 
           end
 
-          {
-            files: [target],
-            converter: self.class.name
-          }
+          target
 
         end
 

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

@@ -1,17 +1,17 @@
-require_relative "base"
+require_relative 'base'
 
 module Libis
   module Format
     module Converter
+
       class XsltConverter < Libis::Format::Converter::Base
+
         def self.input_types
           [:XML]
         end
 
         def self.output_types(format = nil)
-          if format
-            return [] unless input_types.include?(format)
-          end
+          return [] unless input_types.include?(format) if format
           [:XML, :HTML, :TXT]
         end
 
@@ -28,20 +28,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"
+            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)
+            File.open(target, 'w') {|f| f.write(result.to_s)}
           else
-            require "nokogiri"
+            require 'nokogiri'
 
             doc = nil
             begin
@@ -65,7 +65,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,7 +80,7 @@ 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]}"
@@ -89,14 +89,13 @@ module Libis
               fp.close unless fp.nil? or fp.closed?
             end
 
-            {
-              command: {status: 0},
-              files: [target]
-            }
-
+            target
           end
+
         end
+
       end
+
     end
   end
 end

data/lib/libis/format/identifier.rb

@@ -9,7 +9,7 @@ require 'libis/tools/extend/string'
 require 'libis/tools/extend/empty'
 require 'nori/core_ext/object'
 
-require 'libis/format/type_database'
+require 'libis/format/library'
 
 require_relative 'config'
 require_relative 'tool/fido'
@@ -97,7 +97,7 @@ module Libis
       end
 
       def get_fido_identification(file, result, options)
-        output = ::Libis::Format::Tool::Fido.run(file, options[:recursive], **(options[:fido_options] || {}))
+        output = ::Libis::Format::Tool::Fido.run(file, options[:recursive], options[:fido_options])
         process_tool_output(output, result, options[:base_dir])
         output
       end
@@ -132,7 +132,7 @@ module Libis
             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: '', }
-              file_result.merge! Libis::Format::TypeDatabase.enrich(info, PUID: :puid, MIME: :mimetype, NAME: :format_name)
+              file_result.merge! Libis::Format::Library.enrich(info, puid: :puid, mimetype: :mimetype, name: :format_name)
             end
           rescue => e
             # Do nothing - probably Nokogiri chrashed during validation. Could have many causes
@@ -208,7 +208,7 @@ 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, :mimetypes)
       end
 
       def get_best_result(results)

data/lib/libis/format/info.rb

@@ -0,0 +1,27 @@
+module Libis
+  module Format
+    class Info
+      attr_reader :name, :category, :description, :puids, :mimetypes, :extensions
+
+      def initialize(name:, category:, description: '', puids: [], mimetypes: [], extensions: [])
+        @name = name
+        @category = category
+        @description = description
+        @puids = puids
+        @mimetypes = mimetypes
+        @extensions = extensions
+      end
+
+      def to_hash
+        {
+            name: name,
+            description: description.dup,
+            category: category,
+            puids: puids.dup,
+            mimetypes: mimetypes.dup,
+            extensions: extensions.dup
+        }
+      end
+    end
+  end
+end

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

@@ -1,56 +1,58 @@
-# frozen_string_literal: true
-
 require_relative 'identification_tool'
 
 module Libis
   module Format
     module Tool
+
       class ExtensionIdentification < Libis::Format::Tool::IdentificationTool
-        def run_list(filelist, **_options)
+
+        def run_list(filelist, _options = {})
+
           output = runner(nil, filelist)
 
           process_output(output)
+
         end
 
-        def run_dir(dir, recursive = true, **_options)
+        def run_dir(dir, recursive = true, _options = {})
+
           filelist = find_files(dir, recursive)
 
           output = runner(nil, filelist)
 
           process_output(output)
+
         end
 
-        def run(file, **_options)
+        def run(file, _options)
+
           output = runner(file)
 
           process_output(output)
+
         end
 
         protected
 
         def runner(*args)
+
           args.map do |file|
-            info = ::Libis::Format::TypeDatabase.ext_infos(File.extname(file)).first
-            next unless info
-
-            {
-              filepath: file,
-              mimetype: begin
-                info[:MIME].first
-              rescue StandardError
-                nil
-              end,
-              puid: begin
-                info[:PUID].first
-              rescue StandardError
-                nil
-              end,
-              matchtype: 'extension',
-              tool: :type_database
-            }
+            info = ::Libis::Format::Library.get_info_by(:extension, File.extname(file))
+            if info
+              {
+                  filepath: file,
+                  mimetype: (info[:mimetypes].first rescue nil),
+                  puid: (info[:puids].first rescue nil),
+                  matchtype: 'extension',
+                  tool: :format_library
+              }
+            end
           end.cleanup
+
         end
+
       end
+
     end
   end
-end
+end

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