libis-format 1.2.7 → 1.2.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a1b5fdec2f726d83572f66f78b361b8500247bcf5bdcce56e633998b88758bc4
-  data.tar.gz: 0b09d4cc45338b9c1060c89d80f94ad171e8d2bc43da17b20cd2357521ef78f4
+  metadata.gz: 573be9f0abbf23c061f313ac800ea1d24a930b31038fdba2810e39e8383e0ee8
+  data.tar.gz: 26f481ef822822ff376049fc8cfffe922e30f55bec9c6c5b26ebdb1a7141ec60
 SHA512:
-  metadata.gz: 5ad4a140bfa6bedf2d7b915ec1a51b23fd9b4efdacf468e1cae1505a54c72b0733c6ee3d20981347da3f9fae8a8656416a953754bdc893decb8021f40a58b499
-  data.tar.gz: '0854af4151b126b6d2cb3d8fdd04c2186dcd5dac294b9a800db0256ed0955c3f1d86d54853ea39fbb295fdf5f71d7a016e6e49e71988e3c7f7c595f5a1c9a33e'
+  metadata.gz: 1413ea4713b2bc5b891670414b618f3598421d265f2abac1ba1c2dd474eef3006334d02e195fbf03846d4b6e0b153e8b0503bb1b82d0c349b024917a9093ce27
+  data.tar.gz: e501e85571c11174b269ccdf853a72604856dd5ccf31f45a17796b19d41b064a5a85a6fd35774e009837f29649af0918f549d25d44da2e197f773e757f155938

data/Gemfile

@@ -1,7 +1,13 @@
+# frozen_string_literal: true
+
 source 'https://rubygems.org'
 
 gem 'coveralls', group: :test, require: false
 
 gemspec name: 'libis-format', development_group: :test
 
-gem 'standard'
+group :development do
+  gem 'byebug'
+  gem 'debug'
+  gem 'standard'
+end

data/lib/libis/format/cli/prompt_helper.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'tty-prompt'
 require 'pastel'
 
@@ -5,7 +7,6 @@ module Libis
   module Format
     module Cli
       module PromptHelper
-
         attr_reader :prompt, :pastel
 
         def initialize(*args)
@@ -14,8 +15,6 @@ module Libis
           super
         end
 
-        protected
-
         private
 
         def index_of(list, value)
@@ -25,7 +24,9 @@ module Libis
         end
 
         def ask(question, bool: false, enum: nil, default: nil, mask: false)
-          cmd, args, opts = :ask, [question], {}
+          cmd = :ask
+          args = [question]
+          opts = {}
           if enum
             cmd = :select
             args << enum
@@ -38,50 +39,57 @@ module Libis
           prompt.send(cmd, *args, opts)
         end
 
-        def tree_select(path, question: nil, file: false, page_size: 22, filter: true, cycle: false, create: false,
+        def tree_select(path, question: nil, file: false, page_size: 22, filter: true, cycle: false, create: false, # rubocop:disable Metrics/ParameterLists
                         default_choices: nil)
           path = Pathname.new(path) unless path.is_a? Pathname
 
           return path unless path.exist?
+
           path = path.realpath
 
           dirs = path.children.select(&:directory?).sort
           files = file ? path.children.select(&:file?).sort : []
 
           choices = []
-          choices << {name: "Folder: #{path}", value: path, disabled: file ? '' : false}
+          choices << { name: "Folder: #{path}", value: path, disabled: file ? '' : false }
           choices += default_choices if default_choices
-          choices << {name: '-- new directory --', value: -> do
-            new_name = prompt.ask('new directory name:', modify: :trim, required: true)
-            new_path = path + new_name
-            FileUtils.mkdir(new_path.to_path)
-            new_path
+          if create
+            choices << {
+              name: '-- new directory --',
+              value: lambda {
+                new_name = prompt.ask('new directory name:', modify: :trim, required: true)
+                new_path = path + new_name
+                FileUtils.mkdir(new_path.to_path)
+                new_path
+              }
+            }
           end
-          } if create
 
-          choices << {name: "-- new file --", value: -> do
-            new_name = prompt.ask('new file name:', modify: :trim, required: true)
-            path + new_name
+          if file && create
+            choices << {
+              name: '-- new file --', value: lambda {
+                new_name = prompt.ask('new file name:', modify: :trim, required: true)
+                path + new_name
+              }
+            }
           end
-          } if file && create
 
-          choices << {name: '[..]', value: path.parent}
+          choices << { name: '[..]', value: path.parent }
 
-          dirs.each {|d| choices << {name: "[#{d.basename}]", value: d}}
-          files.each {|f| choices << {name: f.basename.to_path, value: f}}
+          dirs.each { |d| choices << { name: "[#{d.basename}]", value: d } }
+          files.each { |f| choices << { name: f.basename.to_path, value: f } }
 
           question ||= "Select #{'file or ' if files}directory"
           selection = prompt.select question, choices,
-                                    per_page: page_size, filter: filter, cycle: cycle, default: file ? 2 : 1
+                                    per_page: page_size, filter:, cycle:, default: file ? 2 : 1
 
           return selection unless selection.is_a? Pathname
           return selection.to_path if selection == path || selection.file?
 
-          tree_select selection, question: question, file: file, page_size: page_size, filter: filter,
-                      cycle: cycle, create: create, default_choices: default_choices
+          tree_select selection, question:, file:, page_size:, filter:,
+                                 cycle:, create:, default_choices:
         end
-
       end
     end
   end
-end
+end

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative 'base'
 require 'libis/format/identifier'
 require 'chromaprint'
@@ -7,24 +9,19 @@ require 'fileutils'
 module Libis
   module Format
     module Converter
-
       class AudioConverter < Libis::Format::Converter::Base
-
         def self.input_types
-          [:MP3, :FLAC, :AC3, :AAC, :WMA, :ALAC, :WAV, :AIFF, :AMR, :AU, :M4A]
+          %i[MP3 FLAC AC3 AAC WMA ALAC WAV AIFF AMR AU M4A]
         end
 
         def self.output_types(format = nil)
           return [] unless input_types.include?(format)
-          [:MP3, :FLAC, :AC3, :AAC, :WMA, :ALAC, :WAV, :AIFF, :AMR, :AU, :M4A]
-        end
 
-        def initialize
-          super
+          %i[MP3 FLAC AC3 AAC WMA ALAC WAV AIFF AMR AU M4A]
         end
 
-        def quiet(v)
-          @flags[:quiet] = !!v
+        def quiet(value)
+          @flags[:quiet] = !!value
         end
 
         def format(format)
@@ -60,9 +57,9 @@ module Libis
         end
 
         def web_stream(value)
-          if value
-            @options[:codec] = 'mp3'
-          end
+          return unless value
+
+          @options[:codec] = 'mp3'
         end
 
         def preset(stream, name)
@@ -88,7 +85,7 @@ module Libis
 
           elsif File.directory?(source)
 
-            sources = Dir[File.join(source, '**', '*')].reject {|p| File.directory? p}
+            sources = Dir[File.join(source, '**', '*')].reject { |p| File.directory? p }
             assemble_and_convert(sources, target)
 
           else
@@ -96,15 +93,14 @@ module Libis
             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}
+          Tempfile.create(%w[list .txt]) do |f|
+            sources.each { |src| f.puts src }
             opts[:global] ||= []
-            opts[:global] += %w(-f concat)
+            opts[:global] += %w[-f concat]
             f.close
             result = convert_file(f.to_path, target)
           end
@@ -112,19 +108,19 @@ module Libis
         end
 
         def self.sounds_like(file1, file2, threshold, rate, channels)
-          rate ||= 96000
+          rate ||= 96_000
           channels ||= 2
           threshold ||= 0.85
 
-          if File.exists?(file1) && File.exists?(file2)
+          if File.exist?(file1) && File.exist?(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]
-            %x"#{cvt_cmd % [file1, file1_raw, rate, channels]}"
-            %x"#{cvt_cmd % [file2, file2_raw, rate, channels]}"
+            `#{format(cvt_cmd, file1, file1_raw, rate, channels)}`
+            `#{format(cvt_cmd, file2, file2_raw, rate, channels)}`
             file1_audio = File.binread(file1_raw)
             file2_audio = File.binread(file2_raw)
 
@@ -144,16 +140,15 @@ module Libis
           else
             false
           end
-
         rescue Exception => e
-          error "Error comparing sound file #{file1} and #{file2}: #{e.message} @ #{e.backtrace.first}"
+          puts "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')
@@ -161,7 +156,7 @@ module Libis
           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 < 0 ? '-sseof' : '-ss') << @options[:start] if @options[:start]
+          opts[:input] << '-accurate_seek' << (@options[:start].to_i.negative? ? '-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]
@@ -171,9 +166,7 @@ module Libis
 
           Libis::Format::Tool::FFMpeg.run(source, target, opts)
         end
-
       end
-
     end
   end
-end
+end

data/lib/libis/format/identifier.rb

@@ -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

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

@@ -1,58 +1,56 @@
+# 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
-            if info
-              {
-                  filepath: file,
-                  mimetype: (info[:MIME].first rescue nil),
-                  puid: (info[:PUID].first rescue nil),
-                  matchtype: 'extension',
-                  tool: :type_database
-              }
-            end
+            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
+            }
           end.cleanup
-
         end
-
       end
-
     end
   end
-end
+end

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

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

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

@@ -1,49 +1,38 @@
+# 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 = []
 
@@ -61,23 +50,21 @@ 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: timeout,
-              kill_after: timeout * 2
+            'file', *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 && 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?
 
           # 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,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 FopPdf
         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[:fop_jar])
         end
 
-        def self.run(xml, target, options = [])
-          self.new.run xml, target, options
+        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: timeout,
-              kill_after: timeout * 2
+            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
           )
 
-          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