AbsoluteRenamer 0.9.0

data/lib/absolute_renamer/external/parsers/core/general/parser.rb

@@ -0,0 +1,74 @@
+# TODO ajouter une option pour la gestion du nombre de points avant l'extension
+module AbsoluteRenamer
+    class GeneralParser < AbsoluteRenamer::IParser
+        def self.add_options(parser, options)
+            parser.banner << ' [file]...'
+            parser.on_tail('-h', '--help', 'Display this help screen') do
+                puts parser
+                exit 0
+            end
+
+            parser.on('-r', '--replace PATTERN,REPLACEMENT', Array,
+                      'String replacement ex:"pattern/replacement" ') do |data|
+                self.add_replacement(data, options)
+            end
+
+            parser.on('-e', '--regexp-replace PATTERN,REPLACEMENT', Array,
+                      'String replacement using regexp') do |data|
+                self.add_replacement(data, options, true)
+            end
+
+            parser.on('-f', '--format FORMAT',
+                      'Format string used as model') do |format|
+                options[:format] = format
+                @format_given = true
+            end
+
+            parser.on('-x', '--ext-format FORMAT',
+                      'Format string used as model for the extension') do |format|
+                options[:ext_format] = format
+            end
+
+            parser.on('-R', '--recursive',
+                      'Rename files in subdirectories recursively') do
+                options[:rec] = true
+            end
+
+            parser.on('--maxdepth N', Integer, 'Maximum recursion depth') do |depth|
+                options[:maxdepth] = depth
+            end
+
+            parser.on('-m', '--mode MODE', [:rename, :copy, :move, :link],
+                      'Renaming mode. Can be used with --dest DEST.',
+                      '  rename: simply rename files',
+                      '  copy: make a copy of each file in DEST with its new name',
+                      '  move: move each file in DEST with its new name',
+                      '  link: create a symbolic link to each file in DEST' <<
+                      ' with its new name') do |mode|
+                options[:mode] = mode
+            end
+
+            parser.on('--dest DEST', 'Destination directory' <<
+                      ' for copy, move and link modes') do |dest|
+                options[:dest] = File.expand_path(dest)
+            end
+            
+            parser.on('-d', '--directories', 'Directories handling') do
+                options[:dir] = true
+            end
+        end
+
+        def self.add_replacement(data, options, regexp = false)
+            pattern,replace = data[0..1]
+            replace ||= ''
+            pattern = Regexp.new(pattern) if regexp
+            moment = @format_given.nil? ? :before : :after
+            options[:replacements] ||= {}
+            options[:replacements][moment] ||= []
+            options[:replacements][moment] << {:type => pattern.class,
+                                               :pattern => pattern,
+                                               :replace => replace
+                                              }
+        end
+    end
+end

data/lib/absolute_renamer/external/parsers/interactive/parser.rb

@@ -0,0 +1,20 @@
+module AbsoluteRenamer
+    class InteractiveParser < AbsoluteRenamer::IParser
+        def self.add_options(parser, options)
+            parser.on('-i', 'Prompt before each renamming') do
+                options[:interactive] = :always
+            end
+
+            parser.on('-I', 'Prompt once before batch renamming') do
+                options[:interactive] = :once
+            end
+
+            parser.on('--interactive [WHEN]', [:always, :never, :once],
+                      'Prompt according to WHEN: never, once (-I), or always (-i).',
+                      'Without WHEN, prompt always') do |w|
+                w = :always if w.nil?
+                options[:interactive] = w
+            end
+        end
+    end
+end

data/lib/absolute_renamer/external/parsers/listing/parser.rb

@@ -0,0 +1,9 @@
+module AbsoluteRenamer
+    class ListingParser < AbsoluteRenamer::IParser
+        def self.add_options(parser, options)
+            parser.on('-l', '--list', "Only display how files will be renamed") do
+                options[:listing] = true
+            end
+        end
+    end
+end

data/lib/absolute_renamer/external/plugins/interactive/plugin.rb

@@ -0,0 +1,35 @@
+module AbsoluteRenamer
+    class InteractivePlugin < AbsoluteRenamer::IPlugin
+        def before_batch_renaming
+            if conf[:options][:interactive] == :once
+                conf[:files].each do |file|
+                    file.display_change
+                end
+                print "Do you want to rename this files ? [y/N] "
+                begin
+                    resp = STDIN.readline.chomp.downcase
+                rescue Exception => e
+                    puts "\nExiting renamer"
+                    exit(0)
+                end
+                return resp == "y"
+            end
+            true
+        end
+
+        def before_file_renaming(params)
+            if conf[:options][:interactive] == :always
+                params[:file].display_change
+                print "Do you want to rename this file ? [y/N] "
+                begin
+                    resp = STDIN.readline.chomp.downcase
+                rescue Exception => e
+                    puts "\nExiting renamer"
+                    exit(0)
+                end
+                return resp == "y"
+            end
+            true
+        end
+    end
+end

data/lib/absolute_renamer/external/plugins/listing/plugin.rb

@@ -0,0 +1,14 @@
+module AbsoluteRenamer
+    class ListingPlugin < AbsoluteRenamer::IPlugin
+        def before_batch_renaming
+            listing = conf[:options][:listing] || false
+            if listing
+                conf[:files].each do |file|
+                    file.display_change
+                end
+                return false
+            end
+            true
+        end
+    end
+end

data/lib/absolute_renamer/file_info.rb

@@ -0,0 +1,90 @@
+require 'ftools'
+require 'fileutils'
+require 'absolute_renamer/use_config'
+require 'absolute_renamer/libs/file'
+
+module AbsoluteRenamer
+    # Class that represents each file to be renamed.
+    # It contains all informations about a file and, in the end,
+    # processes to its renaming.
+    class FileInfo
+        include AbsoluteRenamer::UseConfig
+
+        attr_accessor :name, :new_name,
+                      :path, :real_path,
+                      :ext, :dir, :dir_path
+
+        # Initializes a FileInfo.
+        # path: the relative or absolute path of the file.
+        def initialize(path)
+            @path = path
+            @real_path = File.expand_path(@path)
+            @dir_path = File.dirname(@real_path)
+            @dir = File.directory?(@real_path)
+            @name = File.basename(@real_path)
+            unless @dir
+                # TODO utiliser une conf :dot
+                @ext = File.extname(@name)
+                @name.gsub!(Regexp.new('.' << @ext << '$'), '') unless @ext.empty?
+            end
+        end
+
+        # Returns a description of a FileInfo
+        #   some_fileinfo.inspect           # => "File: hello_world pdf"
+        def inspect
+            "File: #{@name} #{@ext}"
+        end
+
+        # Displays the action that will be done on the file.
+        # some_fileinfo.display_change      # => "rename a_file.txt --> A_File.TXT"
+        def display_change
+            puts "#{conf[:options][:mode]} #{@real_path.sub(Dir.pwd+'/', '')} --> #{new_path.sub(Dir.pwd+'/', '')}"
+        end
+
+        # Returns the new path of the file.
+        def new_path
+            if conf[:options][:dest].nil? or conf[:options][:dest].empty?
+                File.join(@dir_path, @new_name)
+            else
+                File.join(conf[:options][:dest], @new_name)
+            end
+        end
+
+        # Renames the file.
+        def rename
+            display_change
+            File.rename(@real_path, new_path)
+        end
+
+        # Copies the file.
+        def copy
+            display_change
+            if @dir
+                if @real_path != conf[:options][:dest]
+                    FileUtils.cp_r(@real_path, conf[:options][:dest])
+                else
+                    puts "#{real_path} ignored"
+                end
+            else
+                File.copy(@real_path, new_path, false)
+            end
+        end
+
+        # Moves a file. Moving to the same directories is just like renaming.
+        def move
+            display_change
+            File.move(@real_path, new_path, false)
+        end
+
+        # Creates a symbolic link to the file.
+        def link
+            display_change
+            begin
+                File.symlink(@real_path, new_path)
+            rescue NotImplemented
+                # TODO trouver mieux
+                puts "Error: cannot create symlinks"
+            end
+        end
+    end
+end

data/lib/absolute_renamer/imodule.rb

@@ -0,0 +1,68 @@
+require 'absolute_renamer/with_children'
+
+module AbsoluteRenamer
+    # Modules parent class.
+    # Modules must inherit of it.
+    class IModule < AbsoluteRenamer::WithChildren
+        def initialize
+            @filters = []
+        end
+
+        # Returns the classname symbol
+        def self.symbol
+            name.intern
+        end
+
+        # Process a +file+ by searching for a known pattern in its name
+        # and replacing it by the corresponding value.
+        # The pattern is a regular expression obtained by concatening
+        # the +@filters+ variable with "|".
+        #
+        # file: a FileInfo instance
+        # format: the format string used to rename the file
+        # type: the type of the renaming format (:name or :ext)
+        def process(file, format, type = :name)
+            return format if @filters.empty?
+
+            str = format
+            result = []
+            pattern = Regexp.new(@filters.join('|'))
+
+            idx = str.index(pattern)
+            while idx
+                matched = pattern.match(str).to_a.compact
+                part = str.partition(matched[0])
+                result.push(part[0])
+                val = self.interpret(file, matched, type)
+                result.push(val)
+                str = part[2]
+                idx = str.index(pattern)
+            end
+            result.push(str) unless str.empty?
+            format.replace(result.join)
+            format
+        end
+
+        # Interprets a matched pattern.
+        # Searchs for the corresponding callback
+        # in the current module and call it.
+        #
+        # file: a FileInfo instance
+        # infos: the matched values depending of the pattern
+        # type: the type of the renaming format (:name or :ext)
+        def interpret(file, infos, type)
+            modifier = infos[2]
+            action = infos[3]
+
+            return conf[:options][:default_string] unless self.respond_to?(action.intern)
+
+            ap = self.method(action.intern)
+            val = ap.call(file, infos, type)
+            unless modifier.empty?
+                mp = CaseModule.method(CaseModule.actions[modifier])
+                val = mp.call(val)
+            end
+            val.empty? ? conf[:options][:default_string] : val
+        end
+    end
+end

data/lib/absolute_renamer/iparser.rb

@@ -0,0 +1,8 @@
+require 'absolute_renamer/with_children'
+
+module AbsoluteRenamer
+    # Parsers parent class.
+    # Parsers must inherit of it.
+    class IParser < AbsoluteRenamer::WithChildren
+    end
+end

data/lib/absolute_renamer/iplugin.rb

@@ -0,0 +1,11 @@
+require 'absolute_renamer/with_children'
+
+module AbsoluteRenamer
+    # Plugins parent class.
+    # Plugins must inherit of it.
+    class IPlugin < AbsoluteRenamer::WithChildren
+        def self.symbol
+            name.intern
+        end
+    end
+end

data/lib/absolute_renamer/libs/file.rb

@@ -0,0 +1,11 @@
+# Extension of existing File class.
+class << File
+    # Returns the extension of a file.
+    # path: the path of the file
+    # dot: starting from the end, number of dots to count before cuting extension.
+    def extname(path, dot = 1)
+        pattern = (0...dot).inject('') { |pat,x| pat << '\.[^\.]+' } << '$'
+        ext = File.basename(path).match(pattern).to_s
+        ext.empty? ? "" : ext[1..ext.length]
+    end
+end

data/lib/absolute_renamer/libs/string.rb

@@ -0,0 +1,27 @@
+# Extension of existing String class
+class String
+    # Returns a camelized version of a string
+    # word_separator: a regular expression used to separate words.
+    #    str = "hello.THE world"
+    #    str.camelize           # => "Hello.The World"
+    #    str.camelize(/[\.]/)   # => "Hello.The world"
+    #    str                    # => "hello.THE world"
+    def camelize(word_separators = /[\W_]/)
+        self.clone.camelize!(word_separators)
+    end
+
+    # Camelizes a string and returns it.
+    #    str = "Hello.THE World"
+    #    str.camelize!                  # => "Hello.The World"
+    #    str.camelize!(/[\.]/)          # => "Hello.The World"
+    #    str                            # => "Hello.The World"
+    def camelize!(word_separators = /[\W_]/)
+        self.downcase!
+        self.each_char.each_with_index do |c,i|
+            if self[i-1].chr =~ word_separators or i.zero?
+                self[i] = c.upcase if c =~ /[a-z]/
+            end
+        end
+        self
+    end
+end

data/lib/absolute_renamer/parser.rb

@@ -0,0 +1,91 @@
+require 'optparse'
+require 'absolute_renamer/iparser'
+require 'absolute_renamer/use_config'
+require 'pp'
+
+module AbsoluteRenamer
+    # Class in charge of the command line parsing.
+    class Parser
+        class << self
+            include AbsoluteRenamer::UseConfig
+
+            # Calls all registred parsers.
+            # The parsers are written in configuration files.
+            # The core parsers are automaticaly added.
+            def parse_cmd_line
+                parsers_dir = conf[:path][:parsers]
+                parsers = conf[:parsers]
+
+                core_parsers = ['general']
+
+                parsers += core_parsers.map! { |core_parser| File.join('core', core_parser) }
+
+                parsers.each do |parser|
+                    parser_file = File.join(parsers_dir, parser, 'parser.rb')
+                    begin
+                        if require parser_file
+                            puts "Loaded: #{parser_file}" if conf[:debug]
+                        end
+                    rescue LoadError => e
+                        STDERR.puts(e)
+                    end
+                end
+
+                ARGV.options do |parser|
+                    begin
+                        list = AbsoluteRenamer::IParser.children
+                        list.each do |class_name|
+                            class_name.add_options(parser, conf[:options])
+                        end
+                        parser.parse!
+                    rescue RuntimeError => ex
+                        STDERR.puts(ex)
+                        exit 1
+                    end
+                    conf[:files] = self.get_files(ARGV, 0) || []
+                    conf[:options][:maxdepth] ||= 0
+                    conf[:options][:interactive] ||= :never
+                    conf[:options][:mode] ||= :rename
+                    pp conf.get if conf[:debug]
+                end
+            end
+
+            # Creates a list of all files and directories to rename.
+            # All options that have not been matched are considered as path.
+            # For directories, if the recursive otpion is set to true (conf[:rec] == true),
+            # files are searched in sub directories.
+            #
+            # list: a list of path to explore
+            # depth: maximum recursion depth
+            #
+            # Returns the files/directories list
+            def get_files(list, depth)
+                files = []
+                options = conf[:options]
+
+                list.each do |entry|
+                    return files unless File.exists?(entry)
+                    is_dir =   File.directory?(entry)
+                    mod_dir =  options[:dir]
+                    depth_ok = (depth < options[:maxdepth] or options[:maxdepth].zero?)
+                    mod_rec =  (options[:rec] and depth_ok)
+
+                    add_dir =  (is_dir and mod_dir)
+                    add_file = (!is_dir and !mod_dir)
+                    add_sub =  (is_dir and (mod_rec or (!mod_dir and depth < 1)))
+
+                    files << FileInfo.new(entry) if (add_dir or add_file)
+                    files += self.get_files(self.get_subentries(entry), depth + 1) if (add_sub)
+                end
+                files
+            end
+
+            # Returns files and directories contained in +path+.
+            def get_subentries(path)
+                files = Dir.entries(path)
+                files.delete_if { |file| file[0,1] == '.' }
+                files.collect! { |file| path + '/' + file }
+            end
+        end
+    end
+end