filter_rename 1.1.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
-      end unless value.nil?
+        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
 
@@ -96,9 +101,11 @@ module FilterRename
     end
   end
 
-
+  #
+  # Mixin module for all those filters
+  # that make use of indexes.
+  #
   module IndexedParams
-
     attr_reader :params, :params_expanded, :items
 
     def normalize_index(idx)
@@ -106,26 +113,25 @@ module FilterRename
       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
+        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
+    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| normalize_index(y) })).map { |i| i }
+          indexes += Range.new(*(x.split("..").map { |y| normalize_index(y) })).map { |idx| idx }
         elsif x =~ /:/
-          indexes = indexes + x.split(':').map { |y| normalize_index(y) }
+          indexes += x.split(":").map { |y| normalize_index(y) }
         else
           indexes << normalize_index(x)
         end
-
       end
 
       indexes
@@ -146,24 +152,25 @@ module FilterRename
     def filter(params)
       @params = params
       @items = indexed_items
-      @params_expanded = get_indexes
+      @params_expanded = indexes
 
       res = loop_items
 
       if self_targeted?
-        super get_string
+        super(get_string)
       else
-        super res
+        super(res)
       end
     end
   end
 
-
+  #
+  # Base class for all the word
+  # oriented filters
+  #
   class FilterWord < FilterBase
-
     include IndexedParams
 
-
     private
 
     def ws
@@ -185,11 +192,28 @@ module FilterRename
     end
   end
 
-
+  #
+  # Base class for all the number oriented
+  # filters.
+  #
   class FilterNumber < FilterBase
-
     include IndexedParams
 
+    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
 
@@ -198,7 +222,7 @@ module FilterRename
     end
 
     def indexed_items
-      string_to_loop.get_numbers
+      string_to_loop.numbers
     end
 
     def loop_items
@@ -206,43 +230,42 @@ module FilterRename
       numbers = items.clone
 
       params_expanded.each_with_index do |idx, param_idx|
-        numbers[idx] = self.send :filtered_number, numbers[idx], param_idx.next
+        numbers[idx] = send :filtered_number, numbers[idx], param_idx.next
       end
-      str = str.map_number_with_index do |num, i|
-        numbers[i]
+      str.map_number_with_index do |_num, idx|
+        numbers[idx]
       end
-
-      str
     end
   end
 
-
+  #
+  # Base class for all the Regexp
+  # oriented filters.
+  #
   class FilterRegExp < FilterBase
-
     def filter(params)
-      super loop_regex(get_string, params)
+      super(loop_regex(get_string, params))
     end
 
-
     private
 
     def loop_regex(str, params)
-      str = str.gsub(Regexp.new(wrap_regex(params[0]), get_config(:ignore_case).to_boolean)) do |x|
+      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] }
+        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
@@ -259,14 +282,11 @@ module FilterRename
       occurences = items.clone
 
       params_expanded.each_with_index do |idx, param_idx|
-        occurences[idx] = self.send :filtered_occurrence, occurences[idx], param_idx.next
+        occurences[idx] = send :filtered_occurrence, occurences[idx], param_idx.next
       end
-      str = str.gsub(regexp).with_index do |item, i|
-        occurences[i]
+      str.gsub(regexp).with_index do |_idxtem, _i|
+        occurences[idx]
       end
-
-      str
     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