filter_rename 1.0.0 → 1.2.0

data/lib/filter_rename/cli.rb

@@ -1,82 +1,145 @@
-require 'optparse'
-require 'ostruct'
-require 'filter_rename'
-require 'filter_rename/version'
+# frozen_string_literal: true
 
-module FilterRename
+require "optparse"
+require "ostruct"
+require "filter_rename"
+require "filter_rename/version"
 
+module FilterRename
+  #
+  # Parsing the input data.
+  #
   class OptParseMain
-
-    def self.parse(args)
-      options = OpenStruct.new
+    def self.parse(_args)
+      options = Struct.new(:filters, :files, :global, :operation, :show_macro, :help_config).new
       options.filters = []
       options.files = []
       options.global = {}
-      options.operation = :preview
-      options.show_macro = ''
+      options.operation = :diff
+      options.show_macro = ""
+      options.help_config = ""
 
       opt_parser = OptionParser.new do |opt|
-        opt.banner = 'Usage: filter_rename [-g OPTION1[,OPTION2...]] [FILTER1[,FILTER2...]] <file1>[ <file2>...] [OPERATION]'
+        opt.banner = "Usage: filter_rename [-g OPTION1[,OPTION2...]] [FILTER1[,FILTER2...]] <file1>" \
+                     "[ <file2>...] OPERATION"
 
-        opt.separator ''
-        opt.separator 'Operations:'
+        opt.separator ""
+        opt.separator "Operations:"
 
-        opt.on('--apply', 'Apply the changes.') do |c|
+        opt.on("--apply", "Apply the changes.") do |_c|
           options.operation = :apply
         end
 
-        opt.on('-d', '--dry-run', 'Don\'t apply any change but check for errors') do |c|
+        opt.on("-d", "--dry-run", "Don't apply any change but check for errors") do |_c|
           options.operation = :dry_run
         end
 
-        opt.on('-p', '--preview', 'Preview the filter chain applied [DEFAULT]') do |c|
-          options.operation = :preview
+        opt.on("-D", "--diff", "View the changes in a diff format [DEFAULT]") do |_c|
+          options.operation = :diff
         end
 
-        opt.on('-t', '--targets', 'List of targets for each file') do |c|
+        opt.on("-t", "--targets", "List of targets for each file") do |_c|
           options.operation = :targets
         end
 
-        opt.on('-g', '--globals', 'List of global variables') do |c|
+        opt.on("-v", "--values", "List of targets values for each file") do |_c|
+          options.operation = :values
+        end
+
+        opt.on("-g", "--globals", "List of global variables") do |_c|
           options.operation = :globals
         end
 
-        opt.on('-c', '--configs', 'List of filter variables') do |c|
+        opt.on("-c", "--configs", "List of filter variables") do |_c|
           options.operation = :configs
         end
 
-        opt.on('-w', '--words', 'List of groups of words available for translation') do |c|
+        opt.on("-w", "--words", "List of groups of words available for translation") do |_c|
           options.operation = :words
         end
 
-        opt.on('-m', '--macros', 'List of available macros') do |c|
+        opt.on("-m", "--macros", "List of available macros") do |_c|
           options.operation = :macros
         end
 
-        opt.on('-s' , '--show-macro <MACRO>', 'List of commands used by MACRO') do |c|
+        opt.on("-s", "--show-macro <MACRO>", "List of commands used by MACRO") do |c|
           options.operation = :show_macro
           options.show_macro = c
         end
 
-        opt.separator ''
-        opt.separator 'Options:'
+        opt.separator ""
+        opt.separator "Global options:"
+        opt.separator ""
 
-        opt.on('--global [OPTION:VALUE[,OPTION:VALUE]]', 'Override global options with: "option:value"') do |v|
-          v.parametrize.each do |i|
-            options.global.store(i.split(':')[0].to_sym, i.split(':')[1])
+        opt.on("-G", "--global OPTION:VALUE[,OPTION:VALUE]", String,
+               'Override global options with: "option:value"') do |v|
+          v.parametrize.each do |idx|
+            options.global.store(idx.split(":")[0].to_sym, idx.split(":")[1])
           end
         end
 
-        opt.separator ''
-        opt.separator 'Filters:'
+        opt.separator ""
 
-        opt.on('--macro MACRO1,[MACRO2,...]', Array, 'Apply the MACRO' ) do |v|
-          options.filters << MacroConfig.create(v) # { FilterRename::MacroConfig => v }
-#           options.filters.merge MacroConfig.expand_macros(v)
+        opt.on("-V", "--virtual", "Accept a list of file not present in the local drives") do |_c|
+          options.global.store(:mimemagic, false)
+          options.global.store(:essential_tags, true)
+          options.global.store(:check_source, false)
         end
 
-        Filters.constants.sort.each do |c|
+        opt.separator ""
+
+        GlobalConfig::OPTIONS.each do |k, v|
+          if v[:args].nil?
+            opt.on("--[no-]g-#{k.to_s.gsub("_", "-")}", v[:desc]) do |c|
+              options.global.store(k, c)
+            end
+          else
+            opt.on("--g-#{k.to_s.gsub("_", "-")} #{v[:args]}", String, v[:desc]) do |c|
+              options.global.store(k, c)
+            end
+          end
+        end
+
+        opt.separator ""
+        opt.separator "Filter options:"
+        opt.separator ""
+
+        opt.on("-X", "--exclude-files PATTERN", String, "Exclude the files matching the PATTERN") do |c|
+          klass = Object.const_get("FilterRename::Filters::Config")
+          options.filters << { klass => ["grep:#{c}"] }
+          options.filters << { klass => ["grep_exclude:true"] }
+        end
+
+        opt.on("-O", "--only-files PATTERN", String, "Select only the files matching the PATTERN") do |c|
+          klass = Object.const_get("FilterRename::Filters::Config")
+          options.filters << { klass => ["grep:#{c}"] }
+          options.filters << { klass => ["grep_exclude:false"] }
+        end
+
+        opt.on("-M", "--macro MACRO1,[MACRO2,...]", Array, "Apply the MACRO") do |v|
+          options.filters << MacroConfig.create(v)
+        end
+
+        opt.separator ""
 
+        FilterConfig::OPTIONS.each do |k, v|
+          klass = Object.const_get("FilterRename::Filters::Config")
+
+          if v[:args].nil?
+            opt.on("--[no-]f-#{k.to_s.gsub("_", "-")}", v[:desc]) do |c|
+              options.filters << { klass => ["#{k}:#{c}"] }
+            end
+          else
+            opt.on("--f-#{k.to_s.gsub("_", "-")} #{v[:args]}", String, v[:desc]) do |c|
+              options.filters << { klass => ["#{k}:#{c}"] }
+            end
+          end
+        end
+
+        opt.separator ""
+        opt.separator "Filters:"
+
+        Filters.constants.sort.each do |c|
           switch = c.to_s.to_switch
           klass = Object.const_get("FilterRename::Filters::#{c}")
 
@@ -89,57 +152,54 @@ module FilterRename
               options.filters << { klass => v }
             end
           else
-            opt.on("--#{switch} #{klass.params}", "#{klass.hint}") do |v|
+            opt.on("--#{switch} #{klass.params}", klass.hint.to_s) do |v|
               options.filters << { klass => v.parametrize }
             end
           end
         end
 
-        opt.separator ''
-        opt.separator 'Other:'
+        opt.separator ""
+        opt.separator "Other:"
 
-        opt.on_tail('-h', '--help', 'Show this message') do
+        opt.on_tail("-h", "--help", "Show this message") do
           puts opt
           exit
         end
-        opt.on_tail('-v', '--version', 'Show version') do
+
+        opt.on_tail("-H", "--help-config [G-OPTION|F-OPTION]", String,
+                    "Extended description for the available options") do |o|
+          options.operation = :help_config
+          options.help_config = o
+        end
+
+        opt.on_tail("-v", "--version", "Show version") do
           puts VERSION
           exit
         end
       end
 
-      if (!STDIN.tty? && !STDIN.closed?) || !ARGV.empty?
-
+      if (!$stdin.tty? && !$stdin.closed?) || !ARGV.empty?
         opt_parser.parse!(ARGV)
-
-        (ARGV.empty? ? ARGF : ARGV).each do |f|
-          f = File.expand_path(f.strip)
-
-          if File.exists?(f)
-            options.files << f
-          else
-            raise FileNotFound, f
-          end
-        end if [:apply, :preview, :dry_run, :targets].include? options.operation
+        options.files = (ARGV.empty? ? ARGF : ARGV)
       else
-        puts opt_parser; exit
+        puts opt_parser
+        exit
       end
 
       options
     end
-
   end
 
+  #
+  # Interface class to run the application.
+  #
   class CLI
     def self.start
-      begin
-        options = OptParseMain.parse(ARGV)
-        Builder.new(options).send(options.operation)
-      rescue => e
-        Messages.error e
-        exit 1
-      end
+      options = OptParseMain.parse(ARGV)
+      Builder.new(options).send(options.operation)
+    rescue StandardError => e
+      Messages.error e
+      exit 1
     end
   end
-
 end

data/lib/filter_rename/config.rb

@@ -1,100 +1,276 @@
-require 'yaml'
+# frozen_string_literal: true
 
-module FilterRename
+require "yaml"
 
+module FilterRename
+  #
+  # Macro configurations.
+  #
   class MacroConfig
-
     def initialize(cfg)
       cfg.each do |key, value|
-        instance_variable_set('@' + key.to_s, value)
+        instance_variable_set("@#{key}", value)
       end
     end
 
     def get_macro(name)
-      macro = instance_variable_get('@' + name.to_s.gsub(/[^a-zA-Z0-9,-_]/,''))
+      macro = instance_variable_get("@#{name.to_s.gsub(/[^a-zA-Z0-9,\-_]/, "")}")
       raise InvalidMacro, name if macro.nil? || macro.to_s.empty?
+
       macro
     end
 
-    def get_macros
-      instance_variables.map { |m| m.to_s.gsub(/^@/, '') }
+    def macros
+      instance_variables.map { |msg| msg.to_s.gsub(/^@/, "") }
     end
 
     def self.create(name)
       { FilterRename::MacroConfig => name }
     end
-
   end
 
-
+  #
+  # Word filters configurations.
+  #
   class WordsConfig
-
     def initialize(cfg)
       cfg.each do |key, value|
-        instance_variable_set('@' + key.to_s, value)
+        instance_variable_set("@#{key}", value)
       end
     end
 
     def get_words(name, section, idx = nil)
-      w = instance_variable_get('@' + name.to_s)
+      w = instance_variable_get("@#{name}")
       raise InvalidWordsGroup, name if w.nil? || name.to_s.empty?
-      raise InvalidWordsSection.new(name, section) unless w.has_key? section.to_sym
+      raise InvalidWordsSection.new(name, section) unless w.key? section.to_sym
 
       if idx.nil?
-        return w[section]
-      elsif w[section].class == Array
+        w[section]
+      elsif w[section].instance_of?(Array)
         raise InvalidWordsIndex.new(name, section, idx) unless idx < w[section].length
-        return w[section][idx].to_s
+
+        w[section][idx].to_s
       else
-        return w[section].to_s
+        w[section].to_s
       end
     end
   end
 
-
+  #
+  # Global configurations.
+  #
   class GlobalConfig
-    attr_reader :date_format, :hash_type, :counter_length, :counter_start, :targets,
-                :pdf_metadata, :image_metadata, :mp3_metadata
+    OPTIONS = { date_format: { args: "FORMAT",
+                               desc: "Describes the date FORMAT for <mtime> and <ctime> targets.",
+                               long: "This is how the <mtime> and <ctime> targets will be formatted\n" \
+                                     "for each file read, unless the *essential_tags* option is on.\n" \
+                                     "The allowed placeholders are prefixed with a percentage % char\n" \
+                                     "and are the same used by the *date* command.\n" \
+                                     "Use the *date* man page to get more info.",
+                               default: "%Y-%m-%d" },
+                hash_type: { args: "ALGORITHM",
+                             desc: "Use one of the ALGORITHM among sha1, sha2, md5 to create the <hash> target.",
+                             long: "It preloads the <hash> target with one of the allowed value\n" \
+                                   "sha1, sha2, or md5.\n" \
+                                   "Just as reminder, md5 is the less safe but the quicker to be\n" \
+                                   "executed, sha2 is the slowest but the safest.",
+                             default: "md5" },
+                hash_on_tags: { args: nil,
+                                desc: "Enable or not the hash calculation for each file.",
+                                long: "Hash calculation can be expensive, that's why it is disabled\n" \
+                                      "by default and the <hash> target is not created.",
+                                default: false },
+                hash_if_exists: { args: nil,
+                                  desc: "Prints the hash code in case the file exists.",
+                                  long: "This option shows the hash of the two files when the *dry* or\n" \
+                                        "*apply* operation is running and a conflict is raised.\n" \
+                                        "Looking at the hash code would be easier to understand wheter or\n" \
+                                        "not the renaming failure is caused by two clones or two totally\n" \
+                                        "different files that the chain of filters accidentally transformed\n" \
+                                        "in the same filename.",
+                                  default: true },
+                counter_length: { args: "NUMBER",
+                                  desc: "The minimum length of the counter padded by zeros.",
+                                  long: "This is the length of the counter in terms of total NUMBER of\n" \
+                                        "chars rendered.\n" \
+                                        "It means that, when the counter length is less than NUMBER, a certain\n" \
+                                        "number of '0' is prepended to the counter to cover the difference.",
+                                  default: "3" },
+                counter_start: { args: "NUMBER",
+                                 desc: "Start the <count> target from NUMBER+1.",
+                                 long: "This is the way to set the internal counter, that affect the <count>\n" \
+                                       "target, to a specific position.\n" \
+                                       "Be aware that, for technical reasons, it will start from NUMBER+1,\n" \
+                                       "so to have 0 for the first element just set NUMBER to -1",
+                                 default: "0" },
+                inline_targets: { args: nil,
+                                  desc: "Print the targets' list inline or in a column.",
+                                  long: "This option affects the way the target's list for each file is shown:\n" \
+                                        "a *short* list where the data is in the same line, one for RW targets\n" \
+                                        "and one for RO targets, or a *long* list where the data is in column.",
+                                  default: true },
+                pdf_metadata: { args: nil,
+                                desc: "Create the targets from the PDF files metadata.",
+                                long: "This option enable the generation of targets from the metadata\n" \
+                                      "embedded in the PDF files.",
+                                default: true },
+                image_metadata: { args: nil,
+                                  desc: "Create the targets from the image files metadata.",
+                                  long: "This option enable the generation of targets from the metadata\n" \
+                                        "embedded in the supported image files.",
+                                  default: true },
+                audio_metadata: { args: nil,
+                                  desc: "Create the targets from the audio files metadata.",
+                                  long: "This option enable the generation of targets from the metadata\n" \
+                                        "embedded in the supported audio files.",
+                                  default: true },
+                mimemagic: { args: nil,
+                             desc: "Create the extra targets depending from the file's mimetype.",
+                             long: "Disabling it, disable all the extra targets' calculation\n" \
+                                   "based on the file's mimetype.",
+                             default: true },
+                essential_tags: { args: nil,
+                                  desc: "Define whether or not to enable only essential targets.",
+                                  long: "Setting it to true the basic targets only which involve\n" \
+                                        "the file name, path, and extension, will be calculated.\n" \
+                                        "This is useful to use less memory or to skip\n" \
+                                        "those data that can't be calculated in case of a file list\n" \
+                                        "is served by the pipeline.",
+                                  default: false },
+                check_source: { args: nil,
+                                desc: "Define whether or not to enable the source files checking.",
+                                long: "Setting it to false the source files aren't checked out\n" \
+                                      "and a list of files not necessarily in the same machine\n" \
+                                      "could be provided using the pipeline as an input.\n" \
+                                      "Combined with essential_tags to true and mimemagic to false\n" \
+                                      "is useful to avoid errors in that last scenario.",
+                                default: true } }.freeze
+
+    attr_reader(*OPTIONS.keys)
 
+    # rubocop:disable Style/RedundantCondition
     def initialize(cfg)
-      @date_format = cfg[:date_format] || '%Y-%m-%d'
-      @hash_type =  cfg[:hash_type].to_sym || :none
-      @counter_length = cfg[:counter_length] || 4
+      @date_format = cfg[:date_format] || "%Y-%m-%d"
+      @hash_type = cfg[:hash_type].nil? ? :md5 : cfg[:hash_type].to_sym
+      @hash_on_tags = cfg[:hash_on_tags] || false
+      @hash_if_exists = cfg[:hash_if_exists] || true
+      @counter_length = cfg[:counter_length] || 3
       @counter_start = cfg[:counter_start] || 0
-      @targets = cfg[:targets].to_sym || :short
+      @inline_targets = cfg[:inline_targets].nil? ? true : cfg[:inline_targets].to_boolean
       @pdf_metadata = cfg[:pdf_metadata].nil? ? true : cfg[:pdf_metadata].to_boolean
       @image_metadata = cfg[:image_metadata].nil? ? true : cfg[:image_metadata].to_boolean
-      @mp3_metadata = cfg[:mp3_metadata].nil? ? true : cfg[:mp3_metadata].to_boolean
+      @audio_metadata = cfg[:audio_metadata].nil? ? true : cfg[:audio_metadata].to_boolean
+      @mimemagic = cfg[:mimemagic].nil? ? true : cfg[:mimemagic].to_boolean
+      @essential_tags = cfg[:essential_tags].nil? ? false : cfg[:essential_tags].to_boolean
+      @check_source = cfg[:check_source].nil? ? true : cfg[:check_source].to_boolean
     end
+    # rubocop:enable Style/RedundantCondition
   end
 
-
+  #
+  # Filter configurations.
+  #
   class FilterConfig
-    attr_accessor  :word_separator, :target, :ignore_case, :lang, :grep, :grep_on, :grep_exclude, :grep_target
+    OPTIONS = { word_separator: { args: "CHARACTER",
+                                  desc: "Define the CHARACTER that separates two words.",
+                                  long: "This options affects the way a string is split in words or how the\n" \
+                                        "words are joined together.\n" \
+                                        "All the filters that operate with words will use this CHARACTER\n" \
+                                        "to define the sequence of the word itself which can contain all\n" \
+                                        "characters except CHARACTER.",
+                                  default: " " },
+                number_separator: { args: "CHARACTER",
+                                    desc: "Define the CHARACTER to join two or more numbers.",
+                                    long: "This option configure the CHARACTER that will join two or more\n" \
+                                          "numbers in the swap-number filter when an interval is used as\n" \
+                                          "first parameter.",
+                                    default: "." },
+                # This one is unused
+                # occurrence_separator: { args: "CHARACTER"
+                #                         default: "-" },
+                target: { args: "TARGET",
+                          desc: "This is the TARGET name where the filters are operating.",
+                          long: "Switching to one of the available targets allows to alter their content\n" \
+                                "directly using a chain of filters.\n" \
+                                "Targets can be read-write or read-only: the former type reflects the data\n" \
+                                "that will be write back to the file, the latter can be used to generate\n" \
+                                "other values or be emedded in other targets using the *--template* filter.\n" \
+                                "Also custom targets can be defined just to hold data that could be manipulated\n" \
+                                "easier.\n" \
+                                "This option is the same as using the *--select* filter",
+                          default: "name" },
+                ignore_case: { args: nil,
+                               desc: "Ignore or not the character case when searching for strings.",
+                               long: "This option allows to ignore the case during the search and replace\n" \
+                                     "operations, doesn't matter which type of filter is involved.",
+                               default: true },
+                lang: { args: "LANG",
+                        desc: "Set the default LANG code for the *--replace-date* filter.",
+                        long: "This option is used by the *--replace-date* filter to translate groups\n" \
+                              "of words containing the months or day of weeks from a language to another\n" \
+                              "where it's not specified.",
+                        default: "en" },
+                grep: { args: "REGEXP",
+                        desc: "Limit the file to be changed to only those matching the REGEXP pattern.",
+                        long: "This options by default includes from the following filters only those files\n" \
+                              "matching the REGEXP pattern.\n" \
+                              "Depending on the *grep_exclude* option the logic can be inverted and the files\n" \
+                              "matching the REGEXP excluded from the action of the following filters.",
+                        default: ".*" },
+                grep_on_dest: { args: nil,
+                                desc: "Execute the *grep* option on the destination filename.",
+                                long: "To limit the files to be involved in the changes you can apply the\n" \
+                                      "grep option on the source or destination filename.\n" \
+                                      "By default it is executed on the source, while this option allows\n" \
+                                      "to select the destination.\n" \
+                                      "Be aware that the destination changes according to all the previous\n" \
+                                      "filters applied.",
+                                default: false },
+                grep_exclude: { args: nil,
+                                desc: "Invert the logic to exclude the files matching the regular expression.",
+                                long: "With this option the *grep* options will be used to exclude the files\n" \
+                                      "matching the regular expression, from the following chain of filters.",
+                                default: false },
+                grep_target: { args: "TARGET",
+                               desc: "Use the specific TARGET to match files through the *grep* option.",
+                               long: "With this option you can limit the *grep* option to one of the available\n" \
+                                     "TARGETs instead of considering the full filename.\n" \
+                                     "It comes in handy to focus on specific data contained within a TARGET\n" \
+                                     "and the file selection process is exclusively based on that data.",
+                               default: "full_filename" } }.freeze
+
+    attr_accessor(*OPTIONS.keys)
 
+    # rubocop:disable Style/RedundantCondition
     def initialize(cfg)
-      @word_separator = cfg[:word_separator] || ' '
-      @target = cfg[:target].to_sym || :name
+      @word_separator = cfg[:word_separator] || " "
+      @number_separator = cfg[:number_separator] || "."
+      # Unused property
+      @occurrence_separator = cfg[:occurrence_separator] || "-"
+      @target = cfg[:target].nil? ? :name : cfg[:target].to_sym
       @ignore_case = cfg[:ignore_case].nil? ? true : cfg[:ignore_case].to_boolean
       @lang = (cfg[:lang] || :en).to_sym
       @macro = cfg[:macro] || {}
-      @grep = cfg[:grep] || '.*'
-      @grep_on = cfg[:grep_on].to_sym || :source
-      @grep_exclude = cfg[:grep_exclude].to_boolean || false
-      @grep_target = cfg[:grep_target].to_sym || :full_filename
+      @grep = cfg[:grep] || ".*"
+      @grep_on_dest = cfg[:grep_on_dest].nil? ? false : cfg[:grep_on_dest].to_boolean
+      @grep_exclude = cfg[:grep_exclude].nil? ? false : cfg[:grep_exclude].to_boolean
+      @grep_target = (cfg[:grep_target] || :full_filename).to_sym
     end
+    # rubocop:enable Style/RedundantCondition
   end
 
-
+  #
+  # Proxy class for all configurations.
+  #
   class Config
     attr_reader :filter, :global, :macro, :words
 
     def initialize(global = {})
-      cfg = {filter: {}, global: {}, macro: {}, words: {}}
+      cfg = { filter: {}, global: {}, macro: {}, words: {} }
 
-      load_file(File.expand_path(File.join(File.dirname(__FILE__), '..', 'filter_rename.yaml')), cfg)
-      load_file(File.join(ENV['HOME'], '.filter_rename.yaml'), cfg)
-      load_file(File.join(ENV['HOME'], '.filter_rename', 'config.yaml'), cfg)
+      load_file(File.expand_path(File.join(File.dirname(__FILE__), "..", "filter_rename.yaml")), cfg)
+      load_file(File.join(Dir.home, ".filter_rename.yaml"), cfg)
+      load_file(File.join(Dir.home, ".filter_rename", "config.yaml"), cfg)
 
       @filter = FilterConfig.new(cfg[:filter])
       @global = GlobalConfig.new(cfg[:global].merge(global))
@@ -105,16 +281,13 @@ module FilterRename
     private
 
     def load_file(filename, cfg = nil)
+      return unless File.exist?(filename)
 
-      if File.exists?(filename)
-        @filename = filename
-        yaml = YAML.load_file(filename)
-        [:filter, :global, :macro, :words].each do |s|
-          cfg[s].merge!(yaml[s]) if yaml.has_key?(s)
-        end
+      @filename = filename
+      yaml = YAML.load_file(filename)
+      %i[filter global macro words].each do |s|
+        cfg[s].merge!(yaml[s]) if yaml.key?(s)
       end
-
     end
   end
-
 end