libis-format 1.3.7.2 → 2.0.0

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

@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 require_relative 'base'
 require 'libis/format/identifier'
 require 'chromaprint'
@@ -9,19 +7,24 @@ require 'fileutils'
 module Libis
   module Format
     module Converter
+
       class AudioConverter < Libis::Format::Converter::Base
+
         def self.input_types
-          %i[MP3 FLAC AC3 AAC WMA ALAC WAV AIFF AMR AU M4A]
+          [:MP3, :FLAC, :AC3, :AAC, :WMA, :ALAC, :WAV, :AIFF, :AMR, :AU, :M4A]
         end
 
         def self.output_types(format = nil)
-          return [] unless input_types.include?(format)
+          return [] unless format.nil? || input_types.include?(format)
+          [:MP3, :FLAC, :AC3, :AAC, :WMA, :ALAC, :WAV, :AIFF, :AMR, :AU, :M4A]
+        end
 
-          %i[MP3 FLAC AC3 AAC WMA ALAC WAV AIFF AMR AU M4A]
+        def initialize
+          super
         end
 
-        def quiet(value)
-          @flags[:quiet] = !!value
+        def quiet(v)
+          @flags[:quiet] = !!v
         end
 
         def format(format)
@@ -57,70 +60,38 @@ module Libis
         end
 
         def web_stream(value)
-          return unless value
-
-          @options[:codec] = 'mp3'
+          if value
+            @options[:codec] = 'mp3'
+          end
         end
 
         def preset(stream, name)
           (@options[:preset] ||= {})[stream] = name
         end
 
-        # def encoder(value)
-        #   @options[:encoder] = value
-        # end
-        #
-        # def encoder_options(value)
-        #   @options[:encoder_options] = value
-        # end
-
         def convert(source, target, _format, opts = {})
           super
 
           FileUtils.mkpath(File.dirname(target))
 
-          if source.is_a? Array
-
-            assemble_and_convert(source, target)
-
-          elsif File.directory?(source)
-
-            sources = Dir[File.join(source, '**', '*')].reject { |p| File.directory? p }
-            assemble_and_convert(sources, target)
-
-          else
+          convert_file(source, target)
 
-            convert_file(source, target)
-
-          end
-        end
-
-        def assemble_and_convert(sources, target)
-          result = {}
-          Tempfile.create(%w[list .txt]) do |f|
-            sources.each { |src| f.puts src }
-            opts[:global] ||= []
-            opts[:global] += %w[-f concat]
-            f.close
-            result = convert_file(f.to_path, target)
-          end
-          result
         end
 
         def self.sounds_like(file1, file2, threshold, rate, channels)
-          rate ||= 96_000
+          rate ||= 96000
           channels ||= 2
           threshold ||= 0.85
 
-          if File.exist?(file1) && File.exist?(file2)
+          if File.exists?(file1) && File.exists?(file2)
             # Convert input files into raw 16-bit signed audio (WAV) to process with Chramaprint
-            file1_raw = File.join('', 'tmp', "#{File.basename(file1)}.wav")
-            file2_raw = File.join('', 'tmp', "#{File.basename(file2)}.wav")
+            file1_raw = File.join('', 'tmp', File.basename(file1) + '.wav')
+            file2_raw = File.join('', 'tmp', File.basename(file2) + '.wav')
             FileUtils.rm(file1_raw, force: true)
             FileUtils.rm(file2_raw, force: true)
             cvt_cmd = Libis::Format::Config[:raw_audio_convert_cmd]
-            `#{format(cvt_cmd, file1, file1_raw, rate, channels)}`
-            `#{format(cvt_cmd, file2, file2_raw, rate, channels)}`
+            %x"#{cvt_cmd % [file1, file1_raw, rate, channels]}"
+            %x"#{cvt_cmd % [file2, file2_raw, rate, channels]}"
             file1_audio = File.binread(file1_raw)
             file2_audio = File.binread(file2_raw)
 
@@ -140,33 +111,37 @@ module Libis
           else
             false
           end
+
         rescue Exception => e
-          puts "Error comparing sound file #{file1} and #{file2}: #{e.message} @ #{e.backtrace.first}"
+          error "Error comparing sound file #{file1} and #{file2}: #{e.message} @ #{e.backtrace.first}"
           false
         end
 
         protected
 
         def convert_file(source, target)
-          opts = { global: [], input: [], filter: [], output: [] }
-
+          opts = {global: [], input: [], filter: [], output: []}
           opts[:global] << '-hide_banner'
           opts[:global] << '-loglevel' << (@options[:quiet] ? 'fatal' : 'warning')
           opts[:output] << '-vn' # disable input video stream in case it exists
           opts[:output] << '-codec:a' << @options[:codec] if @options[:codec]
           opts[:output] << '-map_metadata:g' << '0:g' # Copy global metadata
           opts[:output] << '-map_metadata:s:a' << '0:s:a' # Copy audio metadata
-          opts[:input] << '-accurate_seek' << (@options[:start].to_i.negative? ? '-sseof' : '-ss') << @options[:start] if @options[:start]
+          opts[:input] << '-accurate_seek' << (@options[:start].to_i < 0 ? '-sseof' : '-ss') << @options[:start] if @options[:start]
           opts[:input] << '-t' << @options[:duration] if @options[:duration]
           opts[:output] << '-q:a' << @options[:quality] if @options[:quality]
           opts[:output] << '-b:a' << @options[:bit_rate] if @options[:bit_rate]
           opts[:output] << '-ar' << @options[:sampling_freq] if @options[:sampling_freq]
           opts[:output] << '-ac' << @options[:channels] if @options[:channels]
           opts[:output] << '-f' << @options[:format] if @options[:format]
-
-          Libis::Format::Tool::FFMpeg.run(source, target, opts)
+          result = Libis::Format::Tool::FFMpeg.run(source, target, opts)
+          info "FFMpeg output: #{result}"
+          result
+          target
         end
+
       end
+
     end
   end
-end
+end

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

@@ -1,16 +1,17 @@
-# frozen_string_literal: true
+# coding: utf-8
 
 ### require 'tools/string'
 require 'tmpdir'
 require 'libis/tools/logger'
 require 'libis/tools/temp_file'
-require 'libis/format/type_database'
+require 'libis/format/library'
 
 require_relative 'repository'
 
 module Libis
   module Format
     module Converter
+
       class Base
         include Libis::Tools::Logger
 
@@ -21,43 +22,58 @@ module Libis
           @flags = {}
         end
 
-        def convert(source, _target, _format, opts = {})
-          unless File.exist? source
-            error "Cannot find file '#{source}'."
-            return nil
+        def self.category
+          :converter
+        end
+
+        def check_file_exist(file)
+          unless File.exist? file
+            error "Cannot find file '#{file}'."
+            return false
+          end
+          true
+        end
+
+        def convert(source, target, format, opts = {})
+          if source.is_a?(Array)
+            return nil unless source.map { |f| check_file_exist(f) }.reduce(:&)
+          else
+            return nil unless check_file_exist(source)
           end
           @options.merge!(opts[:options]) if opts[:options]
           @flags.merge!(opts[:flags]) if opts[:flags]
         end
 
         def self.input_types
-          raise 'Method #input_types needs to be overridden in converter'
+          raise RuntimeError, 'Method #input_types needs to be overridden in converter'
         end
 
         def self.output_types(_format = nil)
-          raise 'Method #output_types needs to be overridden in converter'
+          raise RuntimeError, 'Method #output_types needs to be overridden in converter'
         end
 
         def using_temp(target, &block)
           self.class.using_temp(target, &block)
         end
 
-        def self.using_temp(target)
+        def Base.using_temp(target)
           tempfile = Tools::TempFile.name("convert-#{File.basename(target, '.*').gsub(/\s/, '_')}", File.extname(target))
           result = yield tempfile
           return nil unless result
-
           FileUtils.move result, target
           target
         end
 
-        def self.inherited(klass) # rubocop:disable Lint/MissingSuper
+        def Base.inherited(klass)
+
           Repository.register klass
 
           class << self
+
             def conversions
-              input_types.each_with_object({}) do |input_type, hash|
+              input_types.inject({}) do |hash, input_type|
                 hash[input_type] = output_types
+                hash
               end
             end
 
@@ -70,17 +86,17 @@ module Libis
             end
 
             def input_mimetype?(mimetype)
-              type_id = TypeDatabase.instance.mime_types(mimetype).first
+              type_id = Libis::Format::Library.get_field_by(:mimetype, mimetype, :format)
               input_type? type_id
             end
 
             def output_mimetype?(mimetype)
-              type_id = TypeDatabase.instance.mime_types(mimetype).first
+              type_id = Libis::Format::Library.get_field_by(:mimetype, mimetype, :format)
               output_type? type_id
             end
 
             def conversion?(input_type, output_type)
-              conversions[input_type]&.any? { |t| t == output_type }
+              conversions[input_type] and conversions[input_type].any? { |t| t == output_type }
             end
 
             def output_for(input_type)
@@ -88,11 +104,15 @@ module Libis
             end
 
             def extension?(extension)
-              !TypeDatabase.ext_types(extension).first.nil?
+              !Libis::Format::Library.get_field_by(:extension, extension, :format).nil?
             end
+
           end
+
         end
+
       end
+
     end
   end
 end

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

@@ -1,15 +1,16 @@
-# frozen_string_literal: true
+# coding: utf-8
 
 require 'fileutils'
 require 'deep_dive'
 
 require 'libis/tools/logger'
 require 'libis/tools/extend/hash'
-require 'libis/format/type_database'
+require 'libis/format/library'
 
 module Libis
   module Format
     module Converter
+
       class Chain
         include ::Libis::Tools::Logger
         include DeepDive
@@ -25,16 +26,15 @@ module Libis
         # @return [Array[Hash]]
         def append(converter)
           return [] unless converter
-
           valid_chain_nodes(converter).map do |node|
-            ddup.add_chain_node(node)
+            self.ddup.add_chain_node(node)
           end.compact
         end
 
         def closed?
           !@converter_chain.empty? &&
-            @converter_chain.first[:input].to_sym == @source_format &&
-            @converter_chain.last[:output].to_sym == @target_format
+              @converter_chain.first[:input].to_sym == @source_format &&
+              @converter_chain.last[:output].to_sym == @target_format
         end
 
         def valid?
@@ -49,86 +49,68 @@ module Libis
           @converter_chain.size
         end
 
-        alias length size
+        alias_method :length, :size
 
         def to_s
-          result = @source_format.to_s
-          result << '->-'
-          result << @converter_chain.map { |node| node_to_s(node) }.join('->-')
+          "#{@source_format}->-#{@converter_chain.map do |node|
+            "#{node[:converter].name.gsub(/^.*::/, '')}#{node[:operations].empty? ? '' :
+                "(#{node[:operations].each do |operation|
+                  "#{operation[:method]}:#{operation[:argument]}"
+                end.join(',')})"}->-#{node[:output]}"
+          end.join('->-')}"
         end
 
         def convert(src_file, target_file)
+
           unless valid?
             error 'Converter chain is not valid'
             return nil
           end
 
           temp_files = []
-          xtra_files = []
-
-          result = { commands: [] }
 
           # noinspection RubyParenthesesAroundConditionInspection
-          conversion_success = @converter_chain.each_with_index do |node, i|
-            debug "Converting with node #{node}"
+          result = @converter_chain.each_with_index do |node, i|
+
             target_type = node[:output]
             converter_class = node[:converter]
             converter = converter_class.new
 
-            node[:operations]&.each do |operation|
+            node[:operations].each do |operation|
               converter.send operation[:method], operation[:argument]
-            end
-
-            debug "Converter: #{converter.inspect}"
+            end if node[:operations]
 
             target = target_file
 
             if i < size - 1
-              target += ".temp.#{TypeDatabase.type_extentions(target_type).first}"
-              target += ".#{TypeDatabase.type_extentions(target_type).first}" while File.exist? target
+              target += ".temp.#{Libis::Format::Library.get_field(target_type, :extensions).first}"
+              target += ".#{Libis::Format::Library.get_field(target_type, :extensions).first}" while File.exist? target
               temp_files << target
             end
 
             FileUtils.mkdir_p File.dirname(target)
 
-            debug "Target file: #{target}"
-            r = converter.convert(src_file, target, target_type)
-            debug "Conversion result: #{r}"
+            src_file = converter.convert(src_file, target, target_type)
 
-            src_file = r[:files].first
-            xtra_files += r[:files][1..]
             break :failed unless src_file
 
-            result[:commands] << r.merge(converter: converter_class.name)
-
-            :success
           end
 
-          debug "Final conversion result: #{conversion_success}"
-
-          result[:files] = [src_file] + xtra_files
-
-          debug "Final result: #{result}"
-
           temp_files.each do |f|
             FileUtils.rm(f, force: true)
           end
 
-          conversion_success == :failed ? nil : result
+          result == :failed ? nil : target_file
+
         end
 
         def valid_chain_nodes(converter)
-          source_format = begin
-            @converter_chain.last[:output]
-          rescue StandardError
-            @source_format
-          end
+          source_format = @converter_chain.last[:output] rescue @source_format
           nodes = []
           if converter.input_types.include? source_format
             converter.output_types(source_format).each do |format|
-              node = { converter:, input: source_format, output: format }
+              node = {converter: converter, input: source_format, output: format}
               next if node_exists?(node)
-
               nodes << node
             end
           end
@@ -143,7 +125,6 @@ module Libis
           return nil unless node[:output] && node[:converter].output_types(source_format).include?(node[:output])
           return nil unless node[:converter].input_types.include? source_format
           return nil if node_exists?(node)
-
           @converter_chain << node
           # debug "Chain: #{self}"
           self
@@ -152,16 +133,15 @@ module Libis
         def apply_operations
           temp_chain = @converter_chain.reverse.ddup
           applied = true
-          operations = @operations&.ddup || {}
+          operations = @operations && @operations.ddup || {}
           while (operation = operations.shift)
             method = operation.first.to_s.to_sym
-            applied &&= temp_chain.each do |node|
+            applied &&= :found == temp_chain.each do |node|
               next unless node[:converter].instance_methods.include?(method)
-
               node[:operations] ||= []
-              node[:operations] << { method:, argument: operation.last }
+              node[:operations] << {method: method, argument: operation.last}
               break :found
-            end == :found
+            end
           end
           if applied && operations.empty?
             @converter_chain = temp_chain.reverse
@@ -171,27 +151,17 @@ module Libis
           false
         end
 
-        private
 
-        def node_to_s(node)
-          result = node[:converter].name.gsub(/^.*::/, '').to_s
-          unless node[:operations].empty?
-            result << '('
-            result << node[:operations].map do |operation|
-              "#{operation[:method]}:#{operation[:argument]}"
-            end.join(',')
-            result << ')'
-          end
-          result << '->-'
-          result << node[:output].to_s
-        end
+        private
 
         def node_exists?(node)
           @converter_chain.detect do |n|
             n[:converter] == node[:converter] && n[:input] == node[:input] && n[:output] == node[:output]
           end
         end
+
       end
+
     end
   end
 end

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

@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 require 'nokogiri'
 
 require_relative 'base'
@@ -9,14 +7,15 @@ require 'libis/format/tool/fop_pdf'
 module Libis
   module Format
     module Converter
+
       class FopPdfConverter < Libis::Format::Converter::Base
+
         def self.input_types
           [:XML]
         end
 
         def self.output_types(format = nil)
-          return [] if format && !input_types.include?(format)
-
+          return [] unless input_types.include?(format) if format
           [:PDF]
         end
 
@@ -31,8 +30,13 @@ module Libis
           FileUtils.mkpath(File.dirname(target))
 
           Libis::Format::Tool::FopPdf.run(source, target)
+
+          target
+
         end
+
       end
+
     end
   end
 end

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

@@ -0,0 +1,82 @@
+# encoding: utf-8
+
+require_relative 'base'
+require 'libis/format/identifier'
+
+require 'mini_magick'
+
+MiniMagick.logger.level = ::Logger::UNKNOWN
+
+MiniMagick.configure do |config|
+  # config.cli = :graphicsmagick
+  config.validate_on_create = false
+  config.validate_on_write = false
+  config.whiny = false
+end
+
+module Libis
+  module Format
+    module Converter
+
+      # noinspection RubyTooManyInstanceVariablesInspection,DuplicatedCode
+      class ImageAssembler < Libis::Format::Converter::Base
+
+        def self.input_types
+          [:TIFF, :JPG, :PNG, :BMP, :GIF, :PDF, :JP2]
+        end
+
+        def self.output_types(format = nil)
+          return [] unless input_types.include?(format) if format
+          [:PDF, :TIFF, :GIF, :PBM, :PGM, :PPM]
+        end
+
+        def self.category
+          :assembler
+        end
+
+        def image_assemble(_)
+          #force usage of this converter
+        end
+
+        def quiet(v)
+          @quiet = !!v
+        end
+
+        def convert(source, target, format, opts = {})
+          super
+
+          FileUtils.mkpath(File.dirname(target))
+
+          if source.is_a? Array
+            assemble(source, target, format)
+          elsif File.directory?(source)
+            source_list = Dir[File.join(source, '**', '*')].reject {|p| File.directory? p}
+            assemble(source_list, target, format)
+          else
+            image = MiniMagick::Image.open(source) {|b| b.quiet}
+            if image.pages.size > 1
+              assemble(image.pages.map {|page| page.path}, target, format)
+            else
+              assemble([source], target, format)
+            end
+          end
+
+          target
+
+        end
+
+        private
+
+        def assemble(sources, target, format)
+          MiniMagick::Tool::Convert.new do |b|
+            sources.each {|source| b << source}
+            convert.format(format)
+            b << target
+          end
+        end
+
+      end
+
+    end
+  end
+end