filter_rename 1.0.0 → 1.2.0

data/lib/filter_rename/filter_base.rb

@@ -1,9 +1,13 @@
-require 'delegate'
+# frozen_string_literal: true
 
-module FilterRename
+require "delegate"
+require "keisan"
 
+module FilterRename
+  #
   # This is the class which handles the list
   # of filters.
+  #
   class FilterList
     attr_reader :filters
 
@@ -12,35 +16,34 @@ module FilterRename
     end
 
     def expand_macros!(macro)
-
-      @filters.each_with_index do |names , i|
-
-        if FilterRename::MacroConfig == names.keys[0]
-          z = 1
-          names.values.pop.each do |n|
-            macro.get_macro(n).each do |k, v|
-              if v.nil? # Array
-                @filters.insert(i + z, k.keys[0].to_s.to_filter => k[k.keys[0]])
-              else # Hash
-                @filters.insert(i + z, k.to_s.to_filter => v)
-              end
-              z += 1
+      @filters.each_with_index do |names, idx|
+        next unless names.keys[0] == FilterRename::MacroConfig
+
+        z = 1
+        names.values.pop.each do |n|
+          macro.get_macro(n).each do |k, v|
+            if v.nil? # Array
+              @filters.insert(idx + z, k.keys[0].to_s.to_filter => k[k.keys[0]])
+            else # Hash
+              @filters.insert(idx + z, k.to_s.to_filter => v)
             end
-            @filters[i] = nil
+            z += 1
           end
+          @filters[idx] = nil
         end
       end
 
       @filters.delete_if(&:nil?)
     end
-
   end
 
-
+  #
+  # The base class for all type of
+  # filters.
+  #
   class FilterBase < SimpleDelegator
-
     def initialize(obj, options)
-      super obj
+      super(obj)
       @dest = obj # useful for macros
       @cfg = options[:cfg]
       @words = options[:words]
@@ -51,15 +54,15 @@ module FilterRename
     end
 
     def set_config(name, value)
-      raise InvalidFilterSetting, name unless @cfg.instance_variables.include?("@#{name}".to_sym)
+      raise InvalidFilterSetting, name unless @cfg.instance_variables.include?(:"@#{name}")
 
-      @cfg.instance_variable_set ('@' + name.to_s), value
+      @cfg.instance_variable_set "@#{name}", value
     end
 
     def get_config(name)
-      raise InvalidFilterSetting, name unless @cfg.instance_variables.include?("@#{name}".to_sym)
+      raise InvalidFilterSetting, name unless @cfg.instance_variables.include?(:"@#{name}")
 
-      @cfg.instance_variable_get '@' + name.to_s
+      @cfg.instance_variable_get "@#{name}"
     end
 
     def filter(value)
@@ -67,18 +70,20 @@ module FilterRename
     end
 
     def set_string(value, target = nil)
+      return if value.nil?
+
       if target.nil?
-        super @cfg.target, value
+        super(@cfg.target, value)
       else
-        super target, value
+        super(target, value)
       end
     end
 
     def get_string(target = nil)
       if target.nil?
-        super @cfg.target
+        super(@cfg.target)
       else
-        super target
+        super
       end
     end
 
@@ -91,40 +96,80 @@ module FilterRename
       str
     end
 
+    def current_target
+      @cfg.target.to_s
+    end
   end
 
-
+  #
+  # Mixin module for all those filters
+  # that make use of indexes.
+  #
   module IndexedParams
+    attr_reader :params, :params_expanded, :items
 
-    def get_indexes(params, callback)
+    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 indexes
       indexes = []
-      params_length = (indexed_params == 0) ? params.length : indexed_params
+      params_length = indexed_params.zero? ? 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 += Range.new(*(x.split("..").map { |y| normalize_index(y) })).map { |idx| idx }
+        elsif x =~ /:/
+          indexes += x.split(":").map { |y| normalize_index(y) }
         else
-          indexes << send(callback, x, get_string)
+          indexes << normalize_index(x)
         end
-
       end
 
       indexes
     end
 
+    def string_to_loop
+      get_string
+    end
+
     def indexed_params
       1
     end
-  end
-
 
-  class FilterWord < FilterBase
-    include IndexedParams
+    def self_targeted?
+      false
+    end
 
     def filter(params)
-      super loop_words(get_string, get_indexes(params, :word_idx), params)
+      @params = params
+      @items = indexed_items
+      @params_expanded = indexes
+
+      res = loop_items
+
+      if self_targeted?
+        super(get_string)
+      else
+        super(res)
+      end
     end
+  end
 
+  #
+  # Base class for all the word
+  # oriented filters
+  #
+  class FilterWord < FilterBase
+    include IndexedParams
 
     private
 
@@ -132,60 +177,116 @@ 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
 
+  #
+  # Base class for all the number oriented
+  # filters.
+  #
   class FilterNumber < FilterBase
-
     include IndexedParams
 
-    def filter(params)
-      super loop_numbers(get_string, get_indexes(params, :num_idx), params)
-    end
+    def self.calculator(num, expr)
+      @@calc ||= Keisan::Calculator.new
+      begin
+        @@calc.evaluate("gt()")
+      rescue StandardError
+        @@calc.define_function!(:gt, ->(x) { num > x })
+        @@calc.define_function!(:lt, ->(x) { num < x })
+        @@calc.define_function!(:gte, ->(x) { num >= x })
+        @@calc.define_function!(:lte, ->(x) { num <= x })
+        @@calc.define_function!(:inc, ->(x) { num + x })
+        @@calc.define_function!(:mult, ->(x) { num * x })
+      end
 
+      @@calc.evaluate(expr)
+    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 ns
+      get_config(:number_separator)
+    end
+
+    def indexed_items
+      string_to_loop.numbers
+    end
+
+    def loop_items
+      str = string_to_loop
+      numbers = items.clone
+
+      params_expanded.each_with_index do |idx, param_idx|
+        numbers[idx] = send :filtered_number, numbers[idx], param_idx.next
+      end
+      str.map_number_with_index do |_num, idx|
+        numbers[idx]
       end
-      idx.to_i
     end
+  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
+  #
+  # Base class for all the Regexp
+  # oriented filters.
+  #
+  class FilterRegExp < FilterBase
+    def filter(params)
+      super(loop_regex(get_string, params))
+    end
 
-          num
+    private
+
+    def loop_regex(str, params)
+      str.gsub(Regexp.new(wrap_regex(params[0]), get_config(:ignore_case).to_boolean)) do |_x|
+        matches = Regexp.last_match.clone
+        send(:filtered_regexp, matches.to_a.delete_if(&:nil?), params).to_s.gsub(/\\([0-9]+)/) do |_y|
+          matches[::Regexp.last_match(1).to_i]
         end
       end
-
-      str
     end
   end
 
+  #
+  # Base class for all the occurence
+  # oriented filters.
+  #
+  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] = send :filtered_occurrence, occurences[idx], param_idx.next
+      end
+      str.gsub(regexp).with_index do |_idxtem, _i|
+        occurences[idx]
+      end
+    end
+  end
 end

data/lib/filter_rename/filter_pipe.rb

@@ -1,5 +1,10 @@
-module FilterRename
+# frozen_string_literal: true
 
+module FilterRename
+  #
+  # Class that handles the filters
+  # applying them one after one.
+  #
   class FilterPipe
     attr_reader :source, :dest
 
@@ -8,27 +13,25 @@ module FilterRename
       @cfg = cfg.filter.clone
       @source = FilenameFactory.create(fname, cfg.global)
       @dest = Marshal.load(Marshal.dump(@source))
-      @filters = (filters.class == Array) ? filters : filters.filters
+      @filters = filters.instance_of?(Array) ? filters : filters.filters
       @words = cfg.words
     end
 
     def changed?
-      ! unchanged?
+      !unchanged?
     end
 
     def unchanged?
       @source == @dest
     end
-    alias_method :identical?, :unchanged?
+    alias identical? unchanged?
 
     def diff
       @source.diff(@dest)
     end
 
     def apply
-
-      @filters.each_with_index do |f, i|
-
+      @filters.each_with_index do |f, _i|
         filter = f.keys.pop
         params = f.values.pop
 
@@ -37,7 +40,6 @@ module FilterRename
         else
           filter.new(@dest, cfg: @cfg, words: @words).filter(params) unless skip?
         end
-
       end
 
       self
@@ -50,15 +52,18 @@ module FilterRename
     private
 
     def skip?
-      if [:full_filename, :full_path, :filename].include? @cfg.grep_target.to_sym
-        unmatched = instance_variable_get('@' + @cfg.grep_on.to_s).send(@cfg.grep_target.to_sym).match(Regexp.new(@cfg.grep)).nil?
-      else
-        unmatched = instance_variable_get('@' + @cfg.grep_on.to_s).get_string(@cfg.grep_target).match(Regexp.new(@cfg.grep)).nil?
-      end
+      grep_on = @cfg.grep_on_dest ? :dest : :source
+      unmatched = if %i[full_filename full_path filename].include? @cfg.grep_target.to_sym
+                    instance_variable_get("@#{grep_on}")
+                      .send(@cfg.grep_target.to_sym)
+                      .match(Regexp.new(@cfg.grep)).nil?
+                  else
+                    instance_variable_get("@#{grep_on}")
+                      .get_string(@cfg.grep_target)
+                      .match(Regexp.new(@cfg.grep)).nil?
+                  end
 
       @cfg.grep_exclude.to_s.to_boolean ? !unmatched : unmatched
     end
-
   end
-
 end