AbsoluteRenamer 1.1.0 → 1.1.1

data/lib/absolute_renamer/core-packages/core-interactive/plugin.rb

@@ -1,35 +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
+  class InteractivePlugin < AbsoluteRenamer::IPlugin
+    def before_batch_renaming
+      ask_for_confirmation(:once, 'Do you want to rename this files ?') do
+        conf[:files].each do |file|
+          file.display_change
         end
+      end
+    end
+
+    def before_file_renaming(params)
+      ask_for_confirmation(:always, 'Do you want to rename this file ?') do
+        params[:file].display_change
+      end
+    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
+    def ask_for_confirmation(interactivity, message, waited_answer = 'y')
+      if conf[:options][:interactive] == interactivity
+        yield
+
+        print "#{message} [y/N] "
+
+        begin
+          resp = STDIN.readline.chomp.downcase
+        rescue
+          puts "\nExiting renamer"
+          exit(0)
         end
+
+        return resp == waited_answer
+      end
+      true
     end
+  end
 end

data/lib/absolute_renamer/core-packages/core-listing/parser.rb

@@ -1,9 +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
+  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/core-packages/core-listing/plugin.rb

@@ -1,14 +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
+  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/external.rb

@@ -3,58 +3,58 @@ require 'absolute_renamer/iplugin'
 require 'absolute_renamer/use_config'
 
 begin
-    require 'rubygems'
+  require 'rubygems'
 rescue LoadError
 end
 
 module AbsoluteRenamer
-    # Class in charge of loading external modules.
-    class External
-        class << self
-            include AbsoluteRenamer::UseConfig
-
-            def load_gems
-                if defined?(Gem)
-                    @gems = {}
-
-                    find_gems
-                    find_gems_from_conf
-                    exclude_gems
-
-                    @gems.each do |gem_name, gem_infos|
-                        puts "Loading gem #{gem_name} (#{gem_infos[:version]}) : #{gem_infos[:lib]}" if conf[:debug]
-                        gem gem_name, gem_infos[:version]
-                        require gem_infos[:lib]
-                    end
-                end
-            end
-
-            def find_gems
-                installed_gems = Gem.source_index.find_name(/.*AbsoluteRenamer-.*/).map(&:name).uniq || []
-                installed_gems.each do |gem_name|
-                    @gems[gem_name] = { :lib => gem_name, :version => '>= 0' }
-                end
-            end
-
-            def find_gems_from_conf
-                if conf[:gems]
-                    conf[:gems].each do |gem_name, gem_infos|
-                        @gems[gem_name] = gem_infos ||= {}
-                        @gems[gem_name][:lib] ||= gem_name
-                        @gems[gem_name][:version] ||= ">= 0"
-                    end
-                end
-            end
-
-            def exclude_gems
-                if @conf[:exclude]
-                    @gems.reject! { |gem_name, gem_infos| @conf[:exclude].include? gem_name }
-                end
-            end
-
-            def load_core
-                require 'absolute_renamer/core-packages/core-packages'
-            end
+  # Class in charge of loading external modules.
+  class External
+    class << self
+      include AbsoluteRenamer::UseConfig
+
+      def load_gems
+        if defined?(Gem)
+          @gems = {}
+
+          find_gems
+          find_gems_from_conf
+          exclude_gems
+
+          @gems.each do |gem_name, gem_infos|
+            puts "Loading gem #{gem_name} (#{gem_infos[:version]}) : #{gem_infos[:lib]}" if conf[:debug]
+            gem gem_name, gem_infos[:version]
+            require gem_infos[:lib]
+          end
         end
+      end
+
+      def find_gems
+        installed_gems = Gem.source_index.find_name(/.*AbsoluteRenamer-.*/).map(&:name).uniq || []
+        installed_gems.each do |gem_name|
+          @gems[gem_name] = { :lib => gem_name, :version => '>= 0' }
+        end
+      end
+
+      def find_gems_from_conf
+        if conf[:gems]
+          conf[:gems].each do |gem_name, gem_infos|
+            @gems[gem_name] = gem_infos ||= {}
+            @gems[gem_name][:lib] ||= gem_name
+            @gems[gem_name][:version] ||= ">= 0"
+          end
+        end
+      end
+
+      def exclude_gems
+        if @conf[:exclude]
+          @gems.reject! { |gem_name, gem_infos| @conf[:exclude].include? gem_name }
+        end
+      end
+
+      def load_core
+        require 'absolute_renamer/core-packages/core-packages'
+      end
     end
+  end
 end

data/lib/absolute_renamer/file_info.rb

@@ -4,105 +4,104 @@ 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
+  # 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,
-                      :level
+    attr_accessor :name, :new_name,
+                  :path, :real_path,
+                  :ext, :dir, :dir_path,
+                  :level
 
-        # 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?
-                @level = 0
-            else
-                @level = @real_path.split('/').size
-            end
-        end
+    # 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
+        @ext = File.extname(@name, conf[:options][:dots])
+        @name.gsub!(Regexp.new('.' << @ext << '$'), '') unless @ext.empty?
+        @level = 0
+      else
+        @level = @real_path.split('/').size
+      end
+    end
 
-        # Returns a description of a FileInfo
-        #   some_fileinfo.inspect           # => "File: hello_world pdf"
-        def inspect
-            "File: #{@name} #{@ext}"
-        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 "#{color conf[:options][:mode]} #{@real_path.sub(Dir.pwd+'/', '')} #{color '-->'} #{new_path.sub(Dir.pwd+'/', '')}"
-        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 "#{color conf[:options][:mode]} #{@real_path.sub(Dir.pwd+'/', '')} #{color '-->'} #{new_path.sub(Dir.pwd+'/', '')}"
+    end
 
-        # Returns a text colorized in red.
-        #   color('hello')                  #=> "\e[31mhello\e[0m"
-        def color(text)
-            "\e[31m#{text}\e[0m"
-        end
+    # Returns a text colorized in red.
+    #   color('hello')          #=> "\e[31mhello\e[0m"
+    def color(text)
+      "\e[31m#{text}\e[0m"
+    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
+    # 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
+    # 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
+    # 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
+    # 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
+    # Creates a symbolic link to the file.
+    def link
+      display_change
+      begin
+        File.symlink(@real_path, new_path)
+      rescue NotImplemented
+        puts "Error: cannot create symlinks"
+      end
+    end
 
-        def self.compare_level(a, b)
-          if (a.level == b.level)
-            return (a.name <= b.name) ? -1 : 1
-          else
-            return (a.level < b.level) ? 1 : -1
-          end
-        end
+    # Overriding the comparison operator to sort paths
+    # based on their depth.
+    def <=>(file_info)
+      if (self.level == file_info.level)
+      return (file_info.name <=> self.name)
+      end
+      file_info.level <=> self.level
     end
+  end
 end

data/lib/absolute_renamer/imodule.rb

@@ -1,86 +1,83 @@
 require 'absolute_renamer/with_children'
 
 module AbsoluteRenamer
-    # Modules parent class.
-    # Modules must inherit of it.
-    class IModule < AbsoluteRenamer::WithChildren
-        def initialize
-            @filters = []
-        end
+  # 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
+    # Returns the classname symbol
+    def self.symbol
+      name.intern
+    end
 
-        # Returns a format pattern generated from pattern_string that
-        # can be used to match strings like [*test] in the filename format
-        #   pattern('test') #=> '(\[(.)?test\])'
-        def pattern(pattern_string)
-            Regexp.new "(\\[(.)?#{pattern_string}\\])"
-        end
+    def self.process(file, name_format, ext_format)
+      @mods ||= {}
 
-        # Returns a value modified using a modifier defined in the Case module
-        #   modifiy('value', '&') #=> 'VALUE'
-        #   modifiy('value', '*') #=> 'Value'
-        def modify(val, modifier)
-            if CaseModule.actions.include?(modifier)
-                mod = CaseModule.method(CaseModule.actions[modifier])
-                val = mod.call(val)
-            end
-            val
-        end
+      self.children.each do |mod|
+        mod_sym = mod.symbol
+        @mods[mod_sym] ||= mod.new
+        name_format = @mods[mod_sym].process(file, name_format)
+        ext_format = @mods[mod_sym].process(file, ext_format, :ext) unless file.dir
+      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?
+      [name_format, ext_format]
+    end
 
-            str = format
-            result = []
-            pattern = Regexp.union @filters
+    # Returns a format pattern generated from pattern_string that
+    # can be used to match strings like [*test] in the filename format
+    #   pattern('test') #=> '(\[(.)?test\])'
+    def pattern(pattern_string)
+      Regexp.new "(\\[(.)?#{pattern_string}\\])"
+    end
 
-            idx = str.index(pattern)
-            while idx
-                matched = pattern.match(str).to_a
-                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
+    # Returns a value modified using a modifier defined in the Case module
+    #   modifiy('value', '&') #=> 'VALUE'
+    #   modifiy('value', '*') #=> 'Value'
+    def modify(val, modifier)
+      modification = CaseModule.actions[modifier]
+      val = CaseModule.send(modification, val) unless modification.nil?
+      val
+    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?
 
-        # 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]
+      result = []
+      pattern = Regexp.union @filters
+      idx = format.index(pattern)
 
-            return conf[:options][:default_string] unless self.respond_to?(action.intern)
+      while idx
+        matched = pattern.match(format).to_a
+        part = format.partition(matched[0])
+        result.push(part[0])
+        result.push self.interpret(file, matched, type)
+        format = part[2]
+        idx = format.index(pattern)
+      end
+      result.push(format)
+      format.replace(result.join)
+    end
 
-            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
+    # 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)
+      # This method has to be overriden in every module
     end
+  end
 end