filter_rename 1.1.0 → 1.2.0

data/lib/filter_rename/filename.rb

@@ -1,10 +1,14 @@
-module FilterRename
+# frozen_string_literal: true
 
+module FilterRename
+  #
+  # Basic file attributes translated
+  # to tags to be replaced.
+  #
   class Filename
-
     attr_reader :original
 
-    def self.has_writable_tags
+    def self.writable_tags?
       false
     end
 
@@ -17,12 +21,12 @@ module FilterRename
       load_filename_data(fname)
     end
 
-    def ==(dest)
-      full_filename == dest.full_filename
+    def ==(other)
+      full_filename == other.full_filename
     end
 
-    def !=(dest)
-      full_filename != dest.full_filename
+    def !=(other)
+      full_filename != other.full_filename
     end
 
     def filename
@@ -42,29 +46,27 @@ module FilterRename
     end
 
     def set_string(target, str)
-      instance_variable_set ('@' + target.to_s), str
+      instance_variable_set "@#{target}", str
     end
 
     def get_string(target)
-      instance_variable_get '@' + target.to_s
+      instance_variable_get "@#{target}"
     end
 
-    def has_target?(target)
-      instance_variables.include?(('@' + target.to_s).to_sym)
+    def target?(target)
+      instance_variables.include?(:"@#{target}")
     end
 
     def exists?
-      File.exists?(full_filename)
+      File.exist?(full_filename)
     end
 
     def rename!(dest)
       old_data = {}
 
       if full_filename != dest.full_filename
-        if full_path != dest.full_path
-          FileUtils.mkdir_p(dest.full_path) unless Dir.exists? dest.full_path
-        end
-        unless File.exists?(dest.full_filename)
+        FileUtils.mkdir_p(dest.full_path) if full_path != dest.full_path && !(Dir.exist? dest.full_path)
+        unless File.exist?(dest.full_filename)
           FileUtils.mv full_filename, dest.full_filename
           old_data = { full_filename: full_filename, full_path: full_path, filename: filename }
           load_filename_data(dest.full_filename)
@@ -75,7 +77,8 @@ module FilterRename
     end
 
     def calculate_hash(hash_type = :md5)
-      raise UnknownHashCode, hash_type unless [:sha1, :sha2, :md5].include?(hash_type.to_sym)
+      raise UnknownHashCode, hash_type unless %i[sha1 sha2 md5].include?(hash_type.to_sym)
+
       klass = Object.const_get("Digest::#{hash_type.to_s.upcase}")
       klass.file(full_filename).to_s
     end
@@ -85,47 +88,50 @@ module FilterRename
     end
 
     def pretty_size(size)
-      i = 0; size = size.to_i
-      while ((size >= 1024) && (i < FILE_SIZES.length))
+      i = 0
+      size = size.to_i
+      while (size >= 1024) && (i < FILE_SIZES.length)
         size = size.to_f / 1024
         i += 1
       end
-      size.round(2).to_s.gsub(/.0$/, '') + FILE_SIZES[i]
+      size.round(2).to_s.gsub(/.0$/, "") + FILE_SIZES[i]
     end
 
     def targets
-      res = {:readonly => [], :writable => []}
+      res = { readonly: [], writable: [] }
       instance_variables.each do |v|
         next if v == :@cfg
-        res[instance_variable_get(v).writable? ? :writable : :readonly] << v
+
+        res[instance_variable_get(v).writable? ? :writable : :readonly] << v.to_s.delete("@").to_sym
       end
 
       res
     end
 
     def writable?(tag)
-      instance_variable_get("@#{tag}".to_sym).writable?
+      instance_variable_get(:"@#{tag}").writable?
     end
 
     def custom?(tag)
-      instance_variable_get("@#{tag}".to_sym).custom?
+      instance_variable_get(:"@#{tag}").custom?
     end
 
     def values
       res = {}
       instance_variables.each do |v|
         next if v == :@cfg
-        res[v.to_s.delete('@').to_sym] = instance_variable_get(v)
+
+        res[v.to_s.delete("@").to_sym] = instance_variable_get(v)
       end
       res
     end
 
     protected
 
-    def metatag_to_var!(key, value, readonly = true)
-      var_name = key.downcase.gsub(/[^a-z]/, '_').gsub(/_+/, '_')
-      instance_variable_set('@' + var_name, value.to_s.gsub('/', '_'))
-      instance_variable_get('@' + var_name).readonly! if readonly
+    def metatag_to_var!(key, value, readonly: true)
+      var_name = key.downcase.gsub(/[^a-z]/, "_").gsub(/_+/, "_")
+      instance_variable_set("@#{var_name}", value.to_s.gsub("/", "_"))
+      instance_variable_get("@#{var_name}").readonly! if readonly
     end
 
     private
@@ -133,23 +139,28 @@ module FilterRename
     def load_filename_data(fname)
       @ext = File.extname(fname)
       @name = File.basename(fname, @ext)
-      @path= File.dirname(File.expand_path(fname))
+      @path = File.dirname(File.expand_path(fname))
       @folder = File.basename(@path)
       @path = File.dirname(@path)
 
       # read only stuff
-      @count = @@count.to_s.rjust(@cfg.counter_length.to_i, '0')
-      @ctime = File.ctime(fname).strftime(@cfg.date_format)
-      @mtime = File.mtime(fname).strftime(@cfg.date_format)
-      @size = File.size(fname).to_s
-      @pretty_size = pretty_size(@size)
+      @count = @@count.to_s.rjust(@cfg.counter_length.to_i, "0")
+
+      if @cfg.essential_tags
+        @count.readonly!
+        [@ext, @name, @path, @folder, @path, @count, @original].map(&:basic!)
+      else
+        @ctime = File.ctime(fname).strftime(@cfg.date_format)
+        @mtime = File.mtime(fname).strftime(@cfg.date_format)
+        @size = File.size(fname).to_s
+        @pretty_size = pretty_size(@size)
 
-      [@count, @ctime, @mtime, @size, @pretty_size].map(&:readonly!)
+        [@count, @ctime, @mtime, @size, @pretty_size].map(&:readonly!)
 
-      [@ext, @name, @path, @folder, @path, @count, @ctime, @size, @pretty_size].map(&:basic!)
+        [@ext, @name, @path, @folder, @path, @count, @ctime, @size, @pretty_size, @original].map(&:basic!)
 
-      metatag_to_var!('hash', calculate_hash(@cfg.hash_type), true) if @cfg.hash_on_tags
+        metatag_to_var!("hash", calculate_hash(@cfg.hash_type), readonly: true) if @cfg.hash_on_tags
+      end
     end
   end
-
 end

data/lib/filter_rename/filename_factory.rb

@@ -1,28 +1,35 @@
-require 'mimemagic'
-require 'fileutils'
-require 'differ'
-require 'digest'
+# frozen_string_literal: true
 
-module FilterRename
+require "mimemagic"
+require "fileutils"
+require "differ"
+require "digest"
 
+module FilterRename
+  #
+  # Factory class that returns the
+  # related file handler depending
+  # from its file type.
+  #
   class FilenameFactory
-
     def self.create(fname, cfg)
-
-      return Filename.new(fname, cfg) if File.directory?(fname)
+      return Filename.new(fname, cfg) if File.directory?(fname) || !cfg.mimemagic
 
       magic = MimeMagic.by_magic(File.open(fname))
-      mediatype, type = magic.nil? ? ['unknown', 'unknown'] : [magic.mediatype, magic.type]
+      mediatype, type, subtype = magic.nil? ? %w[unknown unknown unknown] : [magic.mediatype, magic.type, magic.subtype]
 
-      if (IO.read(fname, 3) == 'ID3') && (mediatype == 'audio')
-        require 'filter_rename/filetype/mp3_filename'
+      if (File.read(fname, 3) == "ID3") && (mediatype == "audio")
+        require "filter_rename/filetype/mp3_filename"
         res = Mp3Filename.new(fname, cfg)
-      elsif ((mediatype == 'image') && (! ['vnd.djvu+multipage'].include? type.split('/')[1]))
+      elsif ((mediatype == "audio") && (subtype == "mp4")) || (%w[flac ogg].include? subtype)
+        require "filter_rename/filetype/audio_filename"
+        res = AudioFilename.new(fname, cfg)
+      elsif (mediatype == "image") && (!["vnd.djvu+multipage"].include? type.split("/")[1])
         # supported types: jpeg, png
-        require 'filter_rename/filetype/image_filename'
+        require "filter_rename/filetype/image_filename"
         res = ImageFilename.new(fname, cfg)
-      elsif (type == 'application/pdf')
-        require 'filter_rename/filetype/pdf_filename'
+      elsif type == "application/pdf"
+        require "filter_rename/filetype/pdf_filename"
         res = PdfFilename.new(fname, cfg)
       else
         res = Filename.new(fname, cfg)
@@ -30,7 +37,5 @@ module FilterRename
 
       res
     end
-
   end
-
 end

data/lib/filter_rename/filetype/audio_filename.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+require "taglib"
+
+module FilterRename
+  #
+  # Mp3 files tags handling.
+  #
+  class AudioFilename < Filename
+    def self.writable_tags?
+      true
+    end
+
+    def initialize(fname, cfg)
+      super
+
+      load_audio_data(fname) if cfg.audio_metadata
+    end
+
+    def ==(other)
+      super &&
+        ([@title, @artist, @album, @track, @comment, @year, @genre] ==
+         [other.get_string(:title), other.get_string(:artist), other.get_string(:album), other.get_string(:track),
+          other.get_string(:comment), other.get_string(:year), other.get_string(:genre)])
+    end
+
+    def rename!(dest)
+      old_data = super
+
+      TagLib::FileRef.open(full_filename) do |audio|
+        old_data.merge!({ title: audio.tag.title, artist: audio.tag.artist, album: audio.tag.album,
+                          track: audio.tag.track, comment: audio.tag.comment, year: audio.tag.year,
+                          genre: audio.tag.genre })
+
+        audio.tag.title = dest.get_string(:title)
+        audio.tag.artist = dest.get_string(:artist)
+        audio.tag.album = dest.get_string(:album)
+        audio.tag.track = dest.get_string(:track)
+        audio.tag.comment = dest.get_string(:comment).to_s
+        audio.tag.year = dest.get_string(:year)
+        audio.tag.genre = dest.get_string(:genre)
+
+        audio.save
+      end
+
+      load_audio_data(full_filename)
+
+      old_data
+    end
+
+    def diff(dest)
+      super + "
+       Title:    #{Differ.diff_by_word(dest.get_string(:title).to_s, @title.to_s)}
+       Artist:   #{Differ.diff_by_word(dest.get_string(:artist).to_s, @artist.to_s)}
+       Album:    #{Differ.diff_by_word(dest.get_string(:album).to_s, @album.to_s)}
+       Track:    #{Differ.diff_by_word(dest.get_string(:track).to_s, @track.to_s)}
+       Comments: #{Differ.diff_by_word(dest.get_string(:comment).to_s, @comment.to_s)}
+       Year:     #{Differ.diff_by_word(dest.get_string(:year).to_s, @year.to_s)}
+       Genre:    #{Differ.diff_by_word(dest.get_string(:genre).to_s, @genre.to_s)}
+       "
+    end
+
+    private
+
+    def load_audio_data(fname)
+      audioinfo = TagLib::FileRef.new(fname, true, TagLib::AudioProperties::Average)
+      @title = audioinfo.tag.title.to_s
+      @artist = audioinfo.tag.artist.to_s
+      @album = audioinfo.tag.album.to_s
+      @track = audioinfo.tag.track.to_i
+      @comment = audioinfo.tag.comment.to_s
+      @year = audioinfo.tag.year.to_i
+      @genre = audioinfo.tag.genre.to_s
+
+      # read only stuff
+      @duration = audioinfo.audio_properties.length_in_seconds.to_s
+      @hduration = format "%<h>dh%<m>dm%<s>2ds", { h: @duration.to_i / 3600,
+                                                   m: @duration.to_i / 60 % 60,
+                                                   s: @duration.to_i % 60 }
+      @samplerate = audioinfo.audio_properties.sample_rate.to_s
+      @bitrate = audioinfo.audio_properties.bitrate.to_s
+
+      [@duration, @hduration, @samplerate, @bitrate].map(&:readonly!)
+    end
+  end
+end

data/lib/filter_rename/filetype/image_filename.rb

@@ -1,12 +1,15 @@
-require 'fastimage'
-require 'exiv2'
+# frozen_string_literal: true
 
-module FilterRename
+require "fastimage"
+require "exiv2"
 
+module FilterRename
+  #
+  # Image files tags handling.
+  #
   class ImageFilename < Filename
-
     def initialize(fname, cfg)
-      super fname, cfg
+      super
 
       image = FastImage.new(fname)
       @width = image.size[0].to_s
@@ -14,15 +17,18 @@ module FilterRename
 
       [@width, @height].map(&:readonly!)
 
-      if cfg.image_metadata
-        image = Exiv2::ImageFactory.open(fname)
-        image.read_metadata
+      load_image_data(fname) if cfg.image_metadata
+    end
 
-        image.exif_data.each do |key, value|
-          metadata_to_var!(key, value, true)
-        end unless image.exif_data.nil?
+    def load_image_data(fname)
+      image = Exiv2::ImageFactory.open(fname)
+      image.read_metadata
+
+      return if image.exif_data.nil?
+
+      image.exif_data.each do |key, value|
+        metadata_to_var!(key, value, true)
       end
     end
   end
-
 end

data/lib/filter_rename/filetype/mp3_filename.rb

@@ -1,28 +1,31 @@
-require 'mp3info'
+# frozen_string_literal: true
 
-module FilterRename
+require "mp3info"
 
+module FilterRename
+  #
+  # Mp3 files tags handling.
+  #
   class Mp3Filename < Filename
-
-    def self.has_writable_tags
+    def self.writable_tags?
       true
     end
 
     def initialize(fname, cfg)
-      super fname, cfg
+      super
 
-      load_mp3_data(fname)
+      load_mp3_data(fname) if cfg.audio_metadata
     end
 
-    def ==(dest)
+    def ==(other)
       super &&
-      ([ @title, @artist, @album, @track, @comments, @year, @genre, @genre_s ] ==
-       [ dest.get_string(:title), dest.get_string(:artist), dest.get_string(:album), dest.get_string(:track),
-         dest.get_string(:comments), dest.get_string(:year), dest.get_string(:genre), dest.get_string(:genre_s) ])
+        ([@title, @artist, @album, @track, @comments, @year, @genre, @genre_s] ==
+         [other.get_string(:title), other.get_string(:artist), other.get_string(:album), other.get_string(:track),
+          other.get_string(:comments), other.get_string(:year), other.get_string(:genre), other.get_string(:genre_s)])
     end
 
     def rename!(dest)
-      old_data = super dest
+      old_data = super
 
       Mp3Info.open(full_filename) do |mp3|
         old_data.merge!({ title: mp3.tag.title, artist: mp3.tag.artist, album: mp3.tag.album,
@@ -35,7 +38,7 @@ module FilterRename
         mp3.tag.tracknum = dest.get_string(:track)
         mp3.tag.comments = dest.get_string(:comments).to_s
         mp3.tag.year = dest.get_string(:year)
-        mp3.tag.genre = dest.get_string(:genre).to_i % 256 
+        mp3.tag.genre = dest.get_string(:genre).to_i % 256
         mp3.tag.genre_s = dest.get_string(:genre_s)
       end
 
@@ -45,7 +48,7 @@ module FilterRename
     end
 
     def diff(dest)
-      super(dest) + "
+      super + "
        Title:    #{Differ.diff_by_word(dest.get_string(:title).to_s, @title.to_s)}
        Artist:   #{Differ.diff_by_word(dest.get_string(:artist).to_s, @artist.to_s)}
        Album:    #{Differ.diff_by_word(dest.get_string(:album).to_s, @album.to_s)}
@@ -57,7 +60,6 @@ module FilterRename
        "
     end
 
-
     private
 
     def load_mp3_data(fname)
@@ -69,16 +71,14 @@ module FilterRename
       @comments = mp3info.tag.comments.to_s
       @year = mp3info.tag.year.to_i
       @genre = mp3info.tag.genre.to_i
-      @genre_s =  mp3info.tag.genre_s.to_s
+      @genre_s = mp3info.tag.genre_s.to_s
 
       # read only stuff
-      @vbr = (mp3info.tag.vbr ? 'vbr' : '')
+      @vbr = (mp3info.tag.vbr ? "vbr" : "").dup
       @samplerate = mp3info.samplerate.to_s
       @bitrate = mp3info.bitrate.to_s
 
       [@vbr, @samplerate, @bitrate].map(&:readonly!)
     end
-
   end
-
 end

data/lib/filter_rename/filetype/pdf_filename.rb

@@ -1,24 +1,31 @@
-require 'pdf-reader'
+# frozen_string_literal: true
 
-module FilterRename
+require "pdf-reader"
 
+module FilterRename
+  #
+  # Pdf files tags handling.
+  #
   class PdfFilename < Filename
-
     def initialize(fname, cfg)
-      super fname, cfg
+      super
 
-      if cfg.pdf_metadata
+      load_pdf_data(fname) if cfg.pdf_metadata
+    end
 
-        pdfinfo = PDF::Reader.new(fname)
+    private
 
-        @page_count = pdfinfo.page_count.to_s
-        @page_count.readonly!
+    def load_pdf_data(fname)
+      pdfinfo = PDF::Reader.new(fname)
 
-        pdfinfo.info.each do |key, value|
-          metatag_to_var!(key.to_s.gsub(/([A-Z])([^A-Z]+)/, '\1\2 ').strip, value, true)
-        end unless pdfinfo.info.nil?
+      @page_count = pdfinfo.page_count.to_s
+      @page_count.readonly!
+
+      return if pdfinfo.info.nil?
+
+      pdfinfo.info.each do |key, value|
+        metatag_to_var!(key.to_s.gsub(/([A-Z])([^A-Z]+)/, '\1\2 ').strip, value, readonly: true)
       end
     end
   end
-
 end