filter_rename 1.0.0 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c66a6e6a12b5c1cd51491e73a55596795d6d037aef4a1d75261af07bf0431bb7
-  data.tar.gz: b1979a7d6c40c717b3f2a4b5721ce1e955a83abd8d7ec50607d53b832a57fac8
+  metadata.gz: '0772829a453b3d53a307e213ea42d969c6f5f6598a47ca8c19236b2eae7d46fb'
+  data.tar.gz: ac03f34f6eca2f5650bc283f7c139e4f8032cf87a25134b810eda5716a9577de
 SHA512:
-  metadata.gz: f22d9fd81c17090881c3898067b13e7c5d3e7b8fc3f4799eac73b46d0f96ace2a9aba2a36928231a8d0ba9bd8ec65904cf526f424781def5ba172baf267ee68d
-  data.tar.gz: 8072a807330c8c2daeb6b1f4a4820f14be9ab70c1e7802967e0980a39dcd5900c127285c843914507c485ef140621b03faa8d31fccc2043e652238bdf004f8d3
+  metadata.gz: 4a33e3231cdc186f63cacb21ef752ca78b136a76f64c138ec02cf58470d2ebb02afc35dc5e0a22dbce2a712a93e184faf1a962cce66ab2ef948771fe2f546789
+  data.tar.gz: d08e371afb6cea91b7cef9a228b8e8f4f49bcf3c618b6d1ae0b32664539b744d41a9f02d97fc5537bcc60fa00348f3da54cb10679ba23571beda6c1cf18a5293

data/.github/FUNDING.yml

@@ -0,0 +1,14 @@
+# These are supported funding model platforms
+
+github: [fabiomux]
+#patreon: # Replace with a single Patreon username
+#open_collective: # Replace with a single Open Collective username
+#ko_fi: # Replace with a single Ko-fi username
+#tidelift: # Replace with a single Tidelift platform-name/package-name e.g., npm/babel
+#community_bridge: # Replace with a single Community Bridge project-name e.g., cloud-foundry
+#liberapay: # Replace with a single Liberapay username
+#issuehunt: # Replace with a single IssueHunt username
+#otechie: # Replace with a single Otechie username
+#custom: # Replace with up to 4 custom sponsorship URLs e.g., ['link1', 'link2']
+custom: ['https://www.buymeacoffee.com/DCkNYFg']
+

data/filter_rename.gemspec

@@ -9,16 +9,16 @@ Gem::Specification.new do |spec|
   spec.authors       = ["Fabio Mucciante"]
   spec.email         = ["fabio.mucciante@gmail.com"]
 
-  spec.summary       = %q{Rename filenames through a chain of filter.}
-  spec.description   = %q{Rename filenames applying a cascade of commands called filters in specified portion of it called targets.}
+  spec.summary       = %q{File renaming tool which make use of a chain of actions called filters.}
+  spec.description   = %q{FilterRename is a bulk renaming tool, based on the concept of filters as small operations to perform over sections of the full filename logically represented in targets.}
   spec.homepage      = "https://github.com/fabiomux/filter_rename"
   spec.license       = "GPL-3.0"
 
   spec.metadata      = {
     "bug_tracker_uri"   => "https://github.com/fabiomux/filter_rename/issues",
-    #"changelog_uri"     => "",
+    "changelog_uri"     => "https://freeaptitude.altervista.org/projects/filter-rename.htm#changelog",
     "documentation_uri" => "https://www.rubydoc.info/gems/filter_rename/#{spec.version}",
-    "homepage_uri"      => "https://github.com/fabiomux/filter_rename",
+    "homepage_uri"      => "https://freeaptitude.altervista.org/projects/filter-rename.html",
     #"mailing_list_uri"  => "",
     "source_code_uri"   => "https://github.com/fabiomux/filter_rename",
     "wiki_uri"          => "https://github.com/fabiomux/filter_rename/wiki"

data/lib/filter_rename/cli.rb

@@ -113,7 +113,7 @@ module FilterRename
         opt_parser.parse!(ARGV)
 
         (ARGV.empty? ? ARGF : ARGV).each do |f|
-          f = File.expand_path(f.strip)
+          f = File.expand_path(f.chomp)
 
           if File.exists?(f)
             options.files << f

data/lib/filter_rename/config.rb

@@ -53,12 +53,14 @@ module FilterRename
 
 
   class GlobalConfig
-    attr_reader :date_format, :hash_type, :counter_length, :counter_start, :targets,
+    attr_reader :date_format, :hash_type, :hash_on_tags, :hash_if_exists, :counter_length, :counter_start, :targets,
                 :pdf_metadata, :image_metadata, :mp3_metadata
 
     def initialize(cfg)
       @date_format = cfg[:date_format] || '%Y-%m-%d'
-      @hash_type =  cfg[:hash_type].to_sym || :none
+      @hash_type = cfg[:hash_type].to_sym || :md5
+      @hash_on_tags = cfg[:hash_on_tags] || false
+      @hash_if_exists = cfg[:hash_if_exists] || false
       @counter_length = cfg[:counter_length] || 4
       @counter_start = cfg[:counter_start] || 0
       @targets = cfg[:targets].to_sym || :short
@@ -70,10 +72,12 @@ module FilterRename
 
 
   class FilterConfig
-    attr_accessor  :word_separator, :target, :ignore_case, :lang, :grep, :grep_on, :grep_exclude, :grep_target
+    attr_accessor :word_separator, :number_separator, :occurrence_separator, :target, :ignore_case, :lang, :grep, :grep_on, :grep_exclude, :grep_target
 
     def initialize(cfg)
       @word_separator = cfg[:word_separator] || ' '
+      @number_separator = cfg[:number_separator] || '.'
+      @occurrence_separator = cfg[:occurrence_separator] || '-'
       @target = cfg[:target].to_sym || :name
       @ignore_case = cfg[:ignore_case].nil? ? true : cfg[:ignore_case].to_boolean
       @lang = (cfg[:lang] || :en).to_sym

data/lib/filter_rename/filename.rb

@@ -2,6 +2,8 @@ module FilterRename
 
   class Filename
 
+    attr_reader :original
+
     def self.has_writable_tags
       false
     end
@@ -11,6 +13,7 @@ module FilterRename
       @@count += 1
       @cfg = cfg
 
+      @original = fname
       load_filename_data(fname)
     end
 
@@ -100,6 +103,14 @@ module FilterRename
       res
     end
 
+    def writable?(tag)
+      instance_variable_get("@#{tag}".to_sym).writable?
+    end
+
+    def custom?(tag)
+      instance_variable_get("@#{tag}".to_sym).custom?
+    end
+
     def values
       res = {}
       instance_variables.each do |v|
@@ -135,7 +146,9 @@ module FilterRename
 
       [@count, @ctime, @mtime, @size, @pretty_size].map(&:readonly!)
 
-      metatag_to_var!('hash', calculate_hash(@cfg.hash_type), true) unless @cfg.hash_type == :none
+      [@ext, @name, @path, @folder, @path, @count, @ctime, @size, @pretty_size].map(&:basic!)
+
+      metatag_to_var!('hash', calculate_hash(@cfg.hash_type), true) if @cfg.hash_on_tags
     end
   end
 

data/lib/filter_rename/filetype/mp3_filename.rb

@@ -16,9 +16,9 @@ module FilterRename
 
     def ==(dest)
       super &&
-      ([ @title, @artist, @album, @track, @comments, @year, @genre ] ==
+      ([ @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(:comments), dest.get_string(:year), dest.get_string(:genre), dest.get_string(:genre_s) ])
     end
 
     def rename!(dest)
@@ -26,8 +26,8 @@ module FilterRename
 
       Mp3Info.open(full_filename) do |mp3|
         old_data.merge!({ title: mp3.tag.title, artist: mp3.tag.artist, album: mp3.tag.album,
-                          tracknum: mp3.tag.tracknum, comments: mp3.tag.comments, year: mp3.tag.year,
-                          genre_s: mp3.tag.genre_s })
+                          track: mp3.tag.tracknum, comments: mp3.tag.comments, year: mp3.tag.year,
+                          genre: mp3.tag.genre, genre_s: mp3.tag.genre_s })
 
         mp3.tag.title = dest.get_string(:title)
         mp3.tag.artist = dest.get_string(:artist)
@@ -35,8 +35,8 @@ 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_s = dest.get_string(:genre)
-
+        mp3.tag.genre = dest.get_string(:genre).to_i % 256 
+        mp3.tag.genre_s = dest.get_string(:genre_s)
       end
 
       load_mp3_data(full_filename)
@@ -53,6 +53,7 @@ module FilterRename
        Comments: #{Differ.diff_by_word(dest.get_string(:comments).to_s, @comments.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)}
+       GenreS:   #{Differ.diff_by_word(dest.get_string(:genre_s).to_s, @genre_s.to_s)}
        "
     end
 
@@ -67,7 +68,8 @@ module FilterRename
       @track = mp3info.tag.tracknum.to_i
       @comments = mp3info.tag.comments.to_s
       @year = mp3info.tag.year.to_i
-      @genre = mp3info.tag.genre_s.to_s
+      @genre = mp3info.tag.genre.to_i
+      @genre_s =  mp3info.tag.genre_s.to_s
 
       # read only stuff
       @vbr = (mp3info.tag.vbr ? 'vbr' : '')

data/lib/filter_rename/filter_base.rb

@@ -71,7 +71,7 @@ module FilterRename
         super @cfg.target, value
       else
         super target, value
-      end
+      end unless value.nil?
     end
 
     def get_string(target = nil)
@@ -91,20 +91,39 @@ module FilterRename
       str
     end
 
+    def current_target
+      @cfg.target.to_s
+    end
   end
 
 
   module IndexedParams
 
-    def get_indexes(params, callback)
+    attr_reader :params, :params_expanded, :items
+
+    def normalize_index(idx)
+      max_length = items.length
+      raise IndexOutOfRange, [idx, max_length] if idx.to_i > max_length || idx.to_i < -max_length
+
+      if idx.to_i.positive?
+        idx = idx.to_i.pred  # % max_length
+      elsif idx.to_i.negative?
+        idx = idx.to_i + max_length # % max_length
+      end
+      idx.to_i
+    end
+
+    def get_indexes
       indexes = []
       params_length = (indexed_params == 0) ? params.length : indexed_params
 
       params[0..params_length.pred].each do |x|
         if x =~ /\.\./
-          indexes = indexes + Range.new(*(x.split('..').map {|y| send(callback, y, get_string) })).map { |i| i }
+          indexes = indexes + Range.new(*(x.split('..').map { |y| normalize_index(y) })).map { |i| i }
+        elsif x =~ /:/
+          indexes = indexes + x.split(':').map { |y| normalize_index(y) }
         else
-          indexes << send(callback, x, get_string)
+          indexes << normalize_index(x)
         end
 
       end
@@ -112,18 +131,37 @@ module FilterRename
       indexes
     end
 
+    def string_to_loop
+      get_string
+    end
+
     def indexed_params
       1
     end
+
+    def self_targeted?
+      false
+    end
+
+    def filter(params)
+      @params = params
+      @items = indexed_items
+      @params_expanded = get_indexes
+
+      res = loop_items
+
+      if self_targeted?
+        super get_string
+      else
+        super res
+      end
+    end
   end
 
 
   class FilterWord < FilterBase
-    include IndexedParams
 
-    def filter(params)
-      super loop_words(get_string, get_indexes(params, :word_idx), params)
-    end
+    include IndexedParams
 
 
     private
@@ -132,56 +170,99 @@ module FilterRename
       get_config(:word_separator)
     end
 
-    def word_idx(idx, str)
-      if idx.to_i.positive?
-        idx = idx.to_i.pred
-      elsif idx.to_i.negative?
-        idx = idx.to_i + str.split(ws).length
-      end
-      idx.to_i
+    def indexed_items
+      string_to_loop.split(ws)
     end
 
-    def loop_words(str, arr_index, params)
-      str = str.split(ws)
+    def loop_items
+      str = items.clone
 
-      arr_index.each_with_index do |idx, param_num|
-        str[idx] = send :filtered_word, str[idx], params, param_num.next
+      params_expanded.each_with_index do |idx, param_num|
+        str[idx] = send :filtered_word, str[idx], param_num.next
       end
 
       str.delete_if(&:nil?).join(ws)
     end
-
   end
 
+
   class FilterNumber < FilterBase
 
     include IndexedParams
 
+
+    private
+
+    def ns
+      get_config(:number_separator)
+    end
+
+    def indexed_items
+      string_to_loop.get_numbers
+    end
+
+    def loop_items
+      str = string_to_loop
+      numbers = items.clone
+
+      params_expanded.each_with_index do |idx, param_idx|
+        numbers[idx] = self.send :filtered_number, numbers[idx], param_idx.next
+      end
+      str = str.map_number_with_index do |num, i|
+        numbers[i]
+      end
+
+      str
+    end
+  end
+
+
+  class FilterRegExp < FilterBase
+
     def filter(params)
-      super loop_numbers(get_string, get_indexes(params, :num_idx), params)
+      super loop_regex(get_string, params)
     end
 
 
     private
 
-    def num_idx(idx, str)
-      if idx.to_i < 0
-        idx = str.scan(/\d+/).length + idx.to_i
-      elsif idx.to_i > 0
-        idx = idx.to_i.pred
+    def loop_regex(str, params)
+      str = str.gsub(Regexp.new(wrap_regex(params[0]), get_config(:ignore_case).to_boolean)) do |x|
+        matches = Regexp.last_match.clone
+        self.send(:filtered_regexp, matches.to_a.delete_if(&:nil?), params).to_s.gsub(/\\([0-9]+)/) { |y| matches[$1.to_i] }
       end
-      idx.to_i
+
+      str
     end
 
-    def loop_numbers(str, arr_index, params)
-      arr_index.each_with_index do |idx, param_idx|
-        str = str.map_number_with_index do |num, i|
-          if idx == i
-            num = self.send :filtered_number, num, params, param_idx.next
-          end
+  end
 
-          num
-        end
+
+  class FilterOccurrence < FilterBase
+
+    include IndexedParams
+
+
+    private
+
+    def os
+      get_config(:occurrence_separator)
+    end
+
+    def indexed_items
+      string_to_loop.scan(Regexp.new(params[indexed_params]))
+    end
+
+    def loop_items
+      str = string_to_loop
+      regexp = Regexp.new(params[indexed_params])
+      occurences = items.clone
+
+      params_expanded.each_with_index do |idx, param_idx|
+        occurences[idx] = self.send :filtered_occurrence, occurences[idx], param_idx.next
+      end
+      str = str.gsub(regexp).with_index do |item, i|
+        occurences[i]
       end
 
       str

data/lib/filter_rename/filters.rb

@@ -32,12 +32,22 @@ module FilterRename
       def self.hint; 'Add NUM to the NTH number'; end
       def self.params; 'NTH,NUM'; end
 
-      def filtered_number(num, params, param_num)
+      def filtered_number(num, param_num)
         num.to_i + params[1].to_i
       end
     end
 
 
+    class AddNumberFrom < FilterNumber
+      def self.hint; 'Add the number from TARGET to the NTH'; end
+      def self.params; 'NTH;TARGET'; end
+
+      def filtered_number(num, param_num)
+        num.to_i + get_string(params[1]).to_i
+      end
+    end
+
+
     class Append < FilterBase
       def self.hint; 'Append the TEXT to the current target'; end
       def self.params; 'TEXT'; end
@@ -85,7 +95,11 @@ module FilterRename
       def self.hint; 'Append the NTH number to TARGET'; end
       def self.params; 'NTH,TARGET'; end
 
-      def filtered_number(num, params, param_num)
+      def self_targeted?
+        params[-1] == current_target
+      end
+
+      def filtered_number(num, param_num)
         str = get_string(params[1])
         set_string("#{str}#{num}", params[1])
         num
@@ -97,7 +111,7 @@ module FilterRename
       def self.hint; 'Append the TEXT to the NTH number'; end
       def self.params; 'NTH,TEXT'; end
 
-      def filtered_number(num, params, param_num)
+      def filtered_number(num, param_num)
         "#{num}#{params[1]}"
       end
     end
@@ -107,7 +121,7 @@ module FilterRename
       def self.hint; 'Append the TEXT to the NTH word'; end
       def self.params; 'NTH,TEXT'; end
 
-      def filtered_word(word, params, param_num)
+      def filtered_word(word, param_num)
         word + params[1]
       end
     end
@@ -117,10 +131,17 @@ module FilterRename
       def self.hint; 'Append the NTH word from TARGET'; end
       def self.params; 'NTH,TARGET'; end
 
-      def filter(params)
-        word = get_string(params[1]).split(ws)
-        idx = word_idx(params[0], word)
-        set_string [get_string, word[idx]].join(ws)
+      def string_to_loop
+        get_string(params[1])
+      end
+
+      def self_targeted?
+        true
+      end
+
+      def filtered_word(word, param_num)
+        set_string([get_string, word].join(ws))
+        word
       end
     end
 
@@ -129,7 +150,11 @@ module FilterRename
       def self.hint; 'Append the NTH word to TARGET'; end
       def self.params; 'NTH,TARGET'; end
 
-      def filtered_word(word, params, param_num)
+      def self_targeted?
+        params[-1] == current_target
+      end
+
+      def filtered_word(word, param_num)
         set_string([get_string(params[1]), word].join(ws), params[1])
         word
       end
@@ -147,6 +172,16 @@ module FilterRename
     end
 
 
+    class CapitalizeWord < FilterWord
+      def self.hint; 'Capitalize the NTH word'; end
+      def self.params; 'NTH'; end
+
+      def filtered_word(word, param_num)
+        word.capitalize
+      end
+    end
+
+
     class CopyFrom < FilterBase
       def self.hint; 'Copy the text from TARGET'; end
       def self.params; 'TARGET'; end
@@ -158,23 +193,46 @@ module FilterRename
 
 
     class CopyNumberTo < FilterNumber
-      def self.hint; 'Move the NTH number to TARGET'; end
+      def self.hint; 'Copy the NTH number to TARGET'; end
       def self.params; 'NTH,TARGET'; end
 
-      def filtered_number(num, params, param_num)
+      def self_targeted?
+        params[-1] == current_target
+      end
+
+      def filtered_number(num, param_num)
         set_string(num, params[1])
         num
       end
     end
 
 
-    class CopyTo < FilterBase
-      def self.hint; 'Copy the text selected by REGEX to TARGET'; end
+    class CopyOccurrenceTo < FilterOccurrence
+      def self.hint; 'Copy the NTH occurrence of REGEX to TARGET'; end
+      def self.params; 'NTH,REGEX,TARGET'; end
+
+      def self_targeted?
+        params[-1] == current_target
+      end
+
+      def filtered_occurrence(occurrence, param_num)
+        set_string(occurrence, params[-1])
+        occurrence
+      end
+    end
+
+
+    class CopyTo < FilterRegExp
+      def self.hint; 'Copy the text selected by REGEX to TARGET or TARGET_#'; end
       def self.params; 'REGEX,TARGET'; end
 
-      def filter(params)
-        set_string(get_string.scan(Regexp.new(wrap_regex(params[0]), get_config(:ignore_case).to_boolean)).pop.to_a.pop, params[1])
-        super get_string
+      def filtered_regexp(matches, params)
+        if matches.length > 2
+          matches[1..-1].each_with_index { |x, i| set_string(x, "#{params[1]}_#{i.next}") }
+        else
+          set_string(matches[1], params[1])
+        end
+        matches[0]
       end
     end
 
@@ -185,12 +243,14 @@ module FilterRename
 
       def indexed_params; 2; end
 
-      def filtered_word(word, params, param_num)
+      def filtered_word(word, param_num)
         case param_num
         when 1
           @word = word
-        when 2
-          word = @word + ws + word
+        when params_expanded.length
+          word = [@word, word].join(ws)
+        else
+          @word = [@word, word].join(ws)
         end
 
         word
@@ -198,14 +258,12 @@ module FilterRename
     end
 
 
-    class Delete < FilterBase
+    class Delete < FilterRegExp
       def self.hint; 'Remove the text matching REGEX'; end
-      def self.params; 'REGEX1[,REGEX2,...]'; end
+      def self.params; 'REGEX'; end
 
-      def filter(params)
-        params.each do |par|
-          super get_string.gsub(Regexp.new(par, get_config(:ignore_case).to_boolean), '')
-        end
+      def filtered_regexp(matches, params)
+        ''
       end
     end
 
@@ -214,17 +272,27 @@ module FilterRename
       def self.hint; 'Remove the NTH number'; end
       def self.params; 'NTH'; end
 
-      def filtered_number(num, params, param_num)
+      def filtered_number(num, param_num)
         ''
       end
     end
 
 
+    class DeleteOccurrence < FilterOccurrence
+      def self.hint; 'Delete the NTH occurrence of REGEXP'; end
+      def self.params; 'NTH,REGEXP'; end
+
+      def filtered_occurrence(occurrence, param_num)
+        nil
+      end
+    end
+
+
     class DeleteWord < FilterWord
       def self.hint; 'Remove the NTH word'; end
       def self.params; 'NTH'; end
 
-      def filtered_word(word, params, param_num)
+      def filtered_word(word, param_num)
         nil
       end
     end
@@ -234,7 +302,7 @@ module FilterRename
       def self.hint; 'Format the NTH number adding leading zeroes to have LENGTH'; end
       def self.params; 'NTH,LENGTH'; end
 
-      def filtered_number(num, params, param_num)
+      def filtered_number(num, param_num)
         num.to_i.to_s.rjust(params[1].to_i, '0')
       end
     end
@@ -244,7 +312,7 @@ module FilterRename
       def self.hint; 'Insert the WORD after the NTH word'; end
       def self.params; 'NTH,WORD'; end
 
-      def filtered_word(word, params, param_num)
+      def filtered_word(word, param_num)
         [word, params[1]].join(ws)
       end
     end
@@ -254,23 +322,54 @@ module FilterRename
       def self.hint; 'Insert the WORD after the NTH word'; end
       def self.params; 'NTH,WORD'; end
 
-      def filtered_word(word, params, param_num)
+      def filtered_word(word, param_num)
         [params[1], word].join(ws)
       end
     end
 
 
+    class JoinNumbers < FilterNumber
+      def self.hint; 'Join the words NTH1 and NTH2 and replace the NTH3 number with it'; end
+      def self.params; 'NTH1,NTH2,NTH3'; end
+
+      def indexed_params; 3; end
+
+      def filtered_number(number, param_num)
+        case param_num
+        when 1
+          @number = number
+          number = nil
+        when params_expanded.length
+          number = @number
+        else
+          @number += number
+          number = nil
+        end
+
+        number
+      end
+    end
+
+
     class JoinWords < FilterWord
-      def self.hint; 'Join the words from NTH1 to NTH2'; end
-      def self.params; 'NTH1,NTH2'; end
+      def self.hint; 'Join the words NTH1 and NTH2 and replace the NTH3 word with it'; end
+      def self.params; 'NTH1,NTH2,NTH3'; end
 
-      def filter(params)
-        res = get_string.split(ws)
-        istart = word_idx(params[0], get_string)
-        iend = word_idx(params[1], get_string)
+      def indexed_params; 3; end
+
+      def filtered_word(word, param_num)
+        case param_num
+        when 1
+          @word = word
+          word = nil
+        when params_expanded.length
+          word = @word
+        else
+          @word += word
+          word = nil
+        end
 
-        res = res.insert(istart, res[istart..iend].join)
-        set_string res.delete_if.with_index { |x, idx| ((istart.next)..(iend.next)).include?(idx) }.join(ws)
+        word
       end
     end
 
@@ -295,43 +394,77 @@ module FilterRename
     end
 
 
-    class MoveTo < FilterBase
-      def self.hint; 'Move the text selected by REGEX to TARGET'; end
+    class LowercaseWord < FilterWord
+      def self.hint; 'Lowercase the NTH word'; end
+      def self.params; 'NTH'; end
+
+      def filtered_word(word, param_num)
+        word.downcase
+      end
+    end
+
+
+    class MoveTo < FilterRegExp
+      def self.hint; 'Move the text selected by REGEX to TARGET or TARGET_#'; end
       def self.params; 'REGEX,TARGET'; end
 
-      def filter(params)
-        regex = Regexp.new(wrap_regex(params[0]), get_config(:ignore_case).to_boolean)
-        set_string(get_string.scan(regex).pop.to_a.pop, params[1])
-        str = get_string.gsub(regex, '')
-        super str
+      def filtered_regexp(matches, params)
+        if matches.length > 2
+          matches[1..-1].each_with_index { |x, i| set_string(x, "#{params[1]}_#{i.next}") }
+        else
+          set_string(matches[1], params[1])
+        end
+        ''
       end
     end
 
 
     class MoveNumberTo < FilterNumber
-      def self.hint; 'Move the NTH number to TARGET'; end
+      def self.hint; 'Move the NTH number to TARGET overwriting it'; end
       def self.params; 'NTH,TARGET'; end
 
-      def filtered_number(num, params, param_num)
+      def self_targeted?
+        params[-1] == current_target
+      end
+
+      def filtered_number(num, param_num)
         set_string(num, params[1])
         ''
       end
     end
 
 
+    class MoveOccurrenceTo < FilterOccurrence
+      def self.hint; 'Move the NTH occurrence of REGEX to TARGET overwriting it'; end
+      def self.params; 'NTH,REGEX,TARGET'; end
+
+      def self_targeted?
+        params[-1] == current_target
+      end
+
+      def filtered_occurrence(occurrence, param_num)
+        set_string(occurrence, params[-1])
+        nil
+      end
+    end
+
+
     class MoveWord < FilterWord
       def self.hint; 'Move the NTH1 word to the NTH2 place'; end
       def self.params; 'NTH1,NTH2'; end
 
       def indexed_params; 2; end
 
-      def filtered_word(word, params, param_num)
+      def filtered_word(word, param_num)
         case param_num
         when 1
           @word = word
           res = nil
-        when 2
+        when params_expanded.length
           res = [word, @word].join(ws)
+        else
+          @word = [@word, word].join(ws)
+          res = nil
         end
 
         res
@@ -340,10 +473,14 @@ module FilterRename
 
 
     class MoveWordTo < FilterWord
-      def self.hint; 'Move the NTH word to TARGET'; end
+      def self.hint; 'Move the NTH word to TARGET overwriting it'; end
       def self.params; 'NTH,TARGET'; end
 
-      def filtered_word(word, params, param_num)
+      def self_targeted?
+        params[-1] == current_target
+      end
+
+      def filtered_word(word, param_num)
         set_string(word, params[1])
         nil
       end
@@ -354,7 +491,7 @@ module FilterRename
       def self.hint; 'Multiply the NTH number with NUM'; end
       def self.params; 'NTH,NUM'; end
 
-      def filtered_number(num, params, param_num)
+      def filtered_number(num, param_num)
         num.to_i * params[1].to_i
       end
     end
@@ -384,7 +521,7 @@ module FilterRename
       def self.hint; 'Prepend the TEXT to the NTH number'; end
       def self.params; 'NTH,TEXT'; end
 
-      def filtered_number(num, params, param_num)
+      def filtered_number(num, param_num)
         "#{params[1]}#{num}"
       end
     end
@@ -394,32 +531,48 @@ module FilterRename
       def self.hint; 'Prepend the TEXT to the NTH word'; end
       def self.params; 'NTH,TEXT'; end
 
-      def filtered_word(word, params, param_num)
+      def filtered_word(word, param_num)
         params[1] + word
       end
     end
 
 
-    class Replace < FilterBase
+    class PrependWordFrom < FilterWord
+      def self.hint; 'Prepend with TARGET the NTH word'; end
+      def self.params; 'NTH,TARGET'; end
+
+      def string_to_loop
+        get_string(params[1])
+      end
+
+      def self_targeted?
+        true
+      end
+
+      def filtered_word(word, param_num)
+        set_string([word, get_string].join(ws))
+        word
+      end
+    end
+
+
+    class Replace < FilterRegExp
       def self.hint; 'Replace the text matching REGEX with REPLACE'; end
       def self.params; 'REGEX,REPLACE'; end
 
-      def filter(params)
-        regexp = Regexp.new(params[0], get_config(:ignore_case).to_boolean)
-        super get_string.gsub(regexp, params[1])
+      def filtered_regexp(matches, params)
+        params[1]
       end
     end
 
 
-    class ReplaceFrom < FilterBase
+    class ReplaceFrom < FilterRegExp
       def self.hint; 'Replace the REGEX matching text with the TARGET content'; end
       def self.params; 'REGEX,TARGET'; end
 
-      def filter(params)
-        regexp = Regexp.new(params[0], get_config(:ignore_case).to_boolean)
-        super get_string.gsub(regexp, get_string(params[1]).to_s)
+      def filtered_regexp(matches, params)
+        get_string(params[1]).to_s
       end
-
     end
 
 
@@ -427,17 +580,27 @@ module FilterRename
       def self.hint; 'Replace the NTH number with NUMBER'; end
       def self.params; 'NTH,NUMBER'; end
 
-      def filtered_number(num, params, param_num)
+      def filtered_number(num, param_num)
         params[1]
       end
     end
 
 
+    class ReplaceOccurrence < FilterOccurrence
+      def self.hint; 'Replace the NTH occurrence of REGEXP with TEXT'; end
+      def self.params; 'NTH,REGEXP,TEXT'; end
+
+      def filtered_occurrence(occurrence, param_num)
+        params[2]
+      end
+    end
+
+
     class ReplaceWord < FilterWord
       def self.hint; 'Replace the NTH word with TEXT'; end
       def self.params; 'NTH,TEXT'; end
 
-      def filtered_word(word, params, param_num)
+      def filtered_word(word, param_num)
         params[1]
       end
     end
@@ -522,7 +685,7 @@ module FilterRename
       def self.hint; 'Split the NTH word using a REGEX with capturing groups'; end
       def self.params; 'NTH,REGEX'; end
 
-      def filtered_word(word, params, param_num)
+      def filtered_word(word, param_num)
         word.scan(Regexp.new(wrap_regex(params[1]), get_config(:ignore_case))).pop.to_a.join(ws)
       end
     end
@@ -544,13 +707,17 @@ module FilterRename
 
       def indexed_params; 2; end
 
-      def filtered_number(num, params, param_num)
+      def filtered_number(num, param_num)
         case param_num
         when 1
           @number = num.clone
-          num = get_string.get_number(params[1].to_i.pred)
-        when 2
+          @last_number = get_string.get_number(params_expanded[-1].to_i)
+          num = @last_number
+        when params_expanded.length
           num = @number
+        else
+          @number = [@number, num].join(ns)
+          num = @last_number
         end
 
         num
@@ -562,15 +729,19 @@ module FilterRename
       def self.hint; 'Swap the NTH1 word with the NTH2'; end
       def self.params; 'NTH1,NTH2'; end
 
-      def indexed_words; 2; end
+      def indexed_params; 2; end
 
-      def filtered_word(word, params, param_num)
+      def filtered_word(word, param_num)
         case param_num
         when 1
           @word = word.clone
-          word = get_string.split(ws)[params[1].to_i.pred]
-        when 2
+          @last_word = get_string.split(ws)[params_expanded[-1]]
+          word = @last_word
+        when params_expanded.length
           word = @word
+        else
+          @word = [@word, word].join(ws)
+          word = nil
         end
 
         word
@@ -627,32 +798,32 @@ module FilterRename
     end
 
 
-    class Wrap < FilterBase
+    class UppercaseWord < FilterWord
+      def self.hint; 'Uppercase the NTH word'; end
+      def self.params; 'NTH'; end
+
+      def filtered_word(word, param_num)
+        word.upcase
+      end
+    end
+
+
+    class Wrap < FilterRegExp
       def self.hint; 'Wrap the text matching REGEX with SEPARATOR1 and SEPARATOR2'; end
       def self.params; 'REGEX,SEPARATOR1,SEPARATOR2'; end
 
-      def filter(params)
-        params[0] = "(#{params[0]})" unless params[0] =~ /[()]+/
-        regexp = Regexp.new("(#{params[0]})", get_config(:ignore_case).to_boolean)
-        super get_string.gsub(regexp, "#{params[1]}\\1#{params[2]}")
+      def filtered_regexp(matches, params)
+        "#{params[1]}#{matches[0]}#{params[2]}"
       end
     end
 
 
     class WrapWords < FilterWord
-      def self.hint; 'Wrap the words between the NTH1 and the NTH2 with SEPARATOR1 and SEPARATOR2'; end
-      def self.params; 'NTH1,NTH2,SEPARATOR1,SEPARATOR2'; end
+      def self.hint; 'Wrap the NTH word with SEPARATOR1 and SEPARATOR2'; end
+      def self.params; 'NTH,SEPARATOR1,SEPARATOR2'; end
 
-      def indexed_words; 2; end
-
-      def filtered_word(word, params, param_num)
-        case param_num
-        when 1
-          word = "#{params[2]}#{word}"
-        when 2
-          word = "#{word}#{params[3]}"
-        end
-        word
+      def filtered_word(word, param_num)
+        "#{params[1]}#{word}#{params[2]}"
       end
     end
   end

data/lib/filter_rename/utils.rb

@@ -1,4 +1,5 @@
 require 'date'
+require 'digest'
 
 module FilterRename
 
@@ -20,6 +21,15 @@ module FilterRename
 
   module ReadableVariables
 
+    def basic!
+      @custom = false
+      self
+    end
+
+    def custom?
+      @custom == true || @custom == nil
+    end
+
     def readonly!
       @writable = false
       self
@@ -112,6 +122,10 @@ module FilterRename
     def get_number(idx)
       self.scan(/\d+/)[idx]
     end
+
+    def get_numbers
+      self.scan(/\d+/)
+    end
   end
 
 
@@ -171,7 +185,7 @@ module FilterRename
       old_source = old_data.empty? ? fp.source.values : old_data
 
       fp.dest.values.each do |k, v|
-        puts "    #{k}: ".bold.green + (old_source[k] || '-') + ' > '.bold.green + v if ((v != old_source[k]) && (!old_source[k].nil?))
+        puts "    #{k}: ".rjust(15, ' ').bold.green + (old_source[k].to_s.empty? ? ' ~ '.bold.red : old_source[k].to_s) + ' => '.bold.green + v.to_s if ((v.to_s != old_source[k].to_s) && fp.source.writable?(k) && fp.source.custom?(k))
       end
     end
 
@@ -179,6 +193,16 @@ module FilterRename
       Messages.error "<#{fp.source.filename}> can't be renamed in <#{fp.dest.filename}>, it exists!"
     end
 
+    def self.file_hash(fp, hash_type, cached = nil)
+      raise UnknownHashCode, hash_type unless [:sha1, :sha2, :md5].include?(hash_type.to_sym)
+      klass = Object.const_get("Digest::#{hash_type.to_s.upcase}")
+      hash_src = klass.file fp.source.filename
+      hash_dest = cached ? klass.file(cached.original) : klass.file(fp.dest.filename)
+
+      puts "    #{hash_src == hash_dest ? '[=]'.green : '[>]'.red} #{hash_type.to_s.upcase} source: #{hash_src.to_s.send(hash_src == hash_dest ? :green : :red)}"
+      puts "    #{hash_src == hash_dest ? '[=]'.green : '[<]'.red} #{hash_type.to_s.upcase} dest:   #{hash_dest.to_s.send(hash_src == hash_dest ? :green : :red)}"
+    end
+
     def self.short_targets(ff)
       self.list [ff.targets[:readonly].map { |s| "<#{s.to_s.delete('@')}>"}.join(', ')], :red, '-'
       self.list [ff.targets[:writable].map { |s| "<#{s.to_s.delete('@')}>"}.join(', ')], :green, '+'
@@ -208,6 +232,12 @@ module FilterRename
     end
   end
 
+  class IndexOutOfRange < StandardError
+    def initialize(values)
+      super "Invalid index '#{values[0]}' out of the range 1..#{values[1]}, -#{values[1]}..-1"
+    end
+  end
+
   class UnknownHashCode < StandardError
     def initialize(hash_type)
       super "Invalid hash type: #{hash_type}"

data/lib/filter_rename/version.rb

@@ -1,3 +1,3 @@
 module FilterRename
-  VERSION = "1.0.0"
+  VERSION = '1.1.0'
 end

data/lib/filter_rename.rb

@@ -48,8 +48,11 @@ module FilterRename
           if old_data[:full_filename]
             Messages.renamed!(old_data, fp.dest)
             Messages.changed_tags(fp, old_data, false) if fp.source.class.has_writable_tags
-          else
+          elsif fp.source.class.has_writable_tags
             Messages.changed_tags(fp, old_data)
+          else
+            Messages.file_exists(fp)
+            Messages.file_hash(fp, @cfg.global.hash_type) if @cfg.global.hash_if_exists
           end
 
         else
@@ -77,7 +80,7 @@ module FilterRename
       raise MissingFiles if @files.empty?
 
       @filters.expand_macros!(@cfg.macro)
-      cache = []
+      cache = {}
 
       Messages.label "Dry Run:"
       @files.each do |src|
@@ -86,16 +89,17 @@ module FilterRename
 
         if fp.unchanged?
           Messages.skipping(fp)
-        elsif (cache.include?(fp.dest.full_filename) || fp.dest.exists?)
+        elsif (cache.keys.include?(fp.dest.full_filename) || fp.dest.exists?)
           if fp.source.full_filename == fp.dest.full_filename
             Messages.changed_tags(fp)
           else
             Messages.file_exists(fp)
+            Messages.file_hash(fp, @cfg.global.hash_type, cache[fp.dest.full_filename]) if @cfg.global.hash_if_exists
           end
         else
           Messages.renamed(fp)
           Messages.changed_tags(fp, {}, false) if fp.source.class.has_writable_tags
-          cache << fp.dest.full_filename
+          cache[fp.dest.full_filename] = fp.dest
         end
       end
     end
@@ -131,7 +135,6 @@ module FilterRename
         end
       end
     end
-
   end
 
 end

data/lib/filter_rename.yaml

@@ -1,6 +1,8 @@
 ---
 :global:
-  :hash_type: :none
+  :hash_type: :md5
+  :hash_on_tags: false
+  :hash_if_exists: true
   :date_format: '%Y-%m-%d'
   :counter_length: 3
   :counter_start: 0
@@ -10,6 +12,8 @@
 :filter:
   :lang: :en
   :word_separator: " "
+  :number_separator: '.'
+  :occurrence_separator: '-'
   :target: :name
   :ignore_case: true
   :grep: '.*'
@@ -113,7 +117,7 @@
       - '\1 \2'
   append_issue:
     :move_to:
-    - '(Issue|Volume) ([0-9]+)'
+    - 'Volume +([0-9]+)|Issue +([0-9]+)'
     - 'tmp'
     :template:
     - '<name> #<tmp>'
@@ -144,7 +148,7 @@
       - ignore_case:false
     -
       :replace:
-      - "([A-Z])([a-z!']+)"
+      - "(?<![A-Z])([A-Z])([a-z!',-]+)"
       - " \\1\\2 "
     -
       :replace:

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: filter_rename
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.1.0
 platform: ruby
 authors:
 - Fabio Mucciante
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-03-16 00:00:00.000000000 Z
+date: 2022-09-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -136,8 +136,9 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description: Rename filenames applying a cascade of commands called filters in specified
-  portion of it called targets.
+description: FilterRename is a bulk renaming tool, based on the concept of filters
+  as small operations to perform over sections of the full filename logically represented
+  in targets.
 email:
 - fabio.mucciante@gmail.com
 executables:
@@ -145,6 +146,7 @@ executables:
 extensions: []
 extra_rdoc_files: []
 files:
+- ".github/FUNDING.yml"
 - ".gitignore"
 - ".rspec"
 - ".travis.yml"
@@ -176,8 +178,9 @@ licenses:
 - GPL-3.0
 metadata:
   bug_tracker_uri: https://github.com/fabiomux/filter_rename/issues
-  documentation_uri: https://www.rubydoc.info/gems/filter_rename/1.0.0
-  homepage_uri: https://github.com/fabiomux/filter_rename
+  changelog_uri: https://freeaptitude.altervista.org/projects/filter-rename.htm#changelog
+  documentation_uri: https://www.rubydoc.info/gems/filter_rename/1.1.0
+  homepage_uri: https://freeaptitude.altervista.org/projects/filter-rename.html
   source_code_uri: https://github.com/fabiomux/filter_rename
   wiki_uri: https://github.com/fabiomux/filter_rename/wiki
 post_install_message: 
@@ -195,8 +198,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.8
+rubygems_version: 3.2.19
 signing_key: 
 specification_version: 4
-summary: Rename filenames through a chain of filter.
+summary: File renaming tool which make use of a chain of actions called filters.
 test_files: []