simonc-AbsoluteRenamer 0.9.1 → 0.9.2

data/AbsoluteRenamer.gemspec

@@ -0,0 +1,83 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE
+# Instead, edit Jeweler::Tasks in Rakefile, and run `rake gemspec`
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{AbsoluteRenamer}
+  s.version = "0.9.2"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Simon COURTOIS"]
+  s.date = %q{2009-09-22}
+  s.default_executable = %q{absrenamer}
+  s.description = %q{Unlike many batch renaming tools, AbsoluteRenamer is able to rename folders.
+                         AbsoluteRenamer is modular and can be extended to adapt itself to any kind of file
+                         or to add new options and features.}
+  s.email = %q{happynoff@free.fr}
+  s.executables = ["absrenamer"]
+  s.extra_rdoc_files = [
+    "LICENSE",
+     "README.rdoc"
+  ]
+  s.files = [
+    ".document",
+     ".gitignore",
+     "AbsoluteRenamer.gemspec",
+     "LICENSE",
+     "README.rdoc",
+     "Rakefile",
+     "VERSION",
+     "bin/absrenamer",
+     "conf/absrenamer/absrenamer.conf",
+     "lib/absolute_renamer.rb",
+     "lib/absolute_renamer/config.rb",
+     "lib/absolute_renamer/external.rb",
+     "lib/absolute_renamer/external/modules/core/case/module.rb",
+     "lib/absolute_renamer/external/modules/core/general/module.rb",
+     "lib/absolute_renamer/external/parsers/core/general/parser.rb",
+     "lib/absolute_renamer/external/parsers/interactive/parser.rb",
+     "lib/absolute_renamer/external/parsers/listing/parser.rb",
+     "lib/absolute_renamer/external/plugins/interactive/plugin.rb",
+     "lib/absolute_renamer/external/plugins/listing/plugin.rb",
+     "lib/absolute_renamer/file_info.rb",
+     "lib/absolute_renamer/imodule.rb",
+     "lib/absolute_renamer/iparser.rb",
+     "lib/absolute_renamer/iplugin.rb",
+     "lib/absolute_renamer/libs/file.rb",
+     "lib/absolute_renamer/libs/string.rb",
+     "lib/absolute_renamer/parser.rb",
+     "lib/absolute_renamer/use_config.rb",
+     "lib/absolute_renamer/with_children.rb",
+     "test/absolute_renamer_test.rb",
+     "test/config_test.rb",
+     "test/file_info_test.rb",
+     "test/file_test.rb",
+     "test/test_helper.rb"
+  ]
+  s.homepage = %q{http://github.com/simonc/AbsoluteRenamer}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.5}
+  s.summary = %q{AbsoluteRenamer is a very powerful tool that helps files and directories renaming using the Krename syntax.}
+  s.test_files = [
+    "test/absolute_renamer_test.rb",
+     "test/config_test.rb",
+     "test/file_info_test.rb",
+     "test/file_test.rb",
+     "test/test_helper.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_development_dependency(%q<thoughtbot-shoulda>, [">= 0"])
+    else
+      s.add_dependency(%q<thoughtbot-shoulda>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<thoughtbot-shoulda>, [">= 0"])
+  end
+end

data/VERSION

@@ -1 +1 @@
-0.9.1
+0.9.2

data/conf/absrenamer/absrenamer.conf

@@ -0,0 +1,34 @@
+:debug:               false
+
+:options:
+    # Prompt :never, :once or :always before renaming
+    :interactive:         :never
+    :format:              '$'
+    :ext_format:          '$'
+
+    # Renaming mode: :rename, :copy, :move, :link
+    :mode:                :rename
+    :maxdepth:            0
+
+    # used when a value is not available (pdfAuthor for a PNG file, ...)
+    :default_string:      '---'
+    
+    # Word separator, regular expression statements can be used
+    # default: '\W_'
+    # This string will be used in AbsoluteRenamer just like this :
+    # [^WORD_SEPARATOR]
+    # Then, \W_ => [^\W_]
+    :word_separator:      '\W_'
+
+:path:
+  :modules:               absolute_renamer/external/modules
+  :parsers:               absolute_renamer/external/parsers
+  :plugins:               absolute_renamer/external/plugins
+
+:parsers:
+  - listing
+  - interactive
+
+:plugins:
+  - listing
+  - interactive

data/lib/absolute_renamer.rb

@@ -0,0 +1,122 @@
+$:.unshift(File.dirname(__FILE__)) unless
+  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+require 'absolute_renamer/config'
+require 'absolute_renamer/with_children'
+require 'absolute_renamer/external'
+require 'absolute_renamer/parser'
+require 'absolute_renamer/file_info'
+require 'absolute_renamer/libs/file'
+require 'absolute_renamer/libs/string'
+require 'absolute_renamer/use_config'
+
+# top level module of AbsoluteRenamer.
+module AbsoluteRenamer
+    VERSION = "0.9.1"
+    
+    # The main class of AbsoluteRenamer.
+    #
+    # Organizes the files and directories renaming process.
+    class Processor
+        class << self
+            include AbsoluteRenamer::UseConfig
+
+            # Creates the new names for each file passed to AbsoluteRenamer.
+            #
+            # Asks to each module if he as something to replace
+            # in the name of each file.
+            #
+            # Calls the +before_names_generation+ entry point.
+            def create_names_list
+                call_entry_point(:before_names_generation)
+                return if conf[:files].empty?
+                mods = {}
+                conf[:files].each do |file|
+                    name = conf[:options][:format].clone
+                    ext = conf[:options][:ext_format].clone
+                    do_replacements(file.name, :before)
+                    AbsoluteRenamer::IModule.children.each do |mod|
+                        mod_sym = mod.symbol
+                        mods[mod_sym] ||= mod.new
+                        name = mods[mod_sym].process(file, name)
+                        ext = mods[mod_sym].process(file, ext, :ext) unless file.dir
+                    end
+                    do_replacements(name, :after)
+                    file.new_name = name
+                    file.new_name << '.' << ext unless (file.dir or file.ext.empty?)
+                end
+                if (conf[:options][:dir] and conf[:options][:rec])
+                  conf[:files].sort! { |a, b| AbsoluteRenamer::FileInfo.compare_level(a, b) }
+                end
+                mods.clear
+            end
+
+            # For each file/dir replaces his name by his new name.
+            #
+            # Calls the following entry points :
+            #   - before_batch_renaming ;
+            #   - before_file_renaming ;
+            #   - after_file_renaming ;
+            #   - after_batch_renaming.
+            def do_renaming
+                if call_entry_point(:before_batch_renaming)
+                    conf[:files].each do |file|
+                        if call_entry_point(:before_file_renaming, :file => file)
+                            if file.respond_to?(conf[:options][:mode])
+                                file.send(conf[:options][:mode])
+                            end
+                            call_entry_point(:after_file_renaming, :file => file)
+                        end
+                    end
+                    call_entry_point(:after_batch_renaming)
+                end
+            end
+
+            # Loads the plugins list in the @plugins variable.
+            def load_plugins
+                @plugins = {}
+                AbsoluteRenamer::IPlugin.children.each do |plugin|
+                    @plugins[plugin.symbol] = plugin.new
+                end
+            end
+
+            # Calls the given entry point for each plugin available
+            #
+            # Ask to each plugin if it implements the entry point
+            # and calls it with params if it isn't null.
+            # It keeps going will all plugins return true.
+            #
+            # returns true if all plugins returned true
+            def call_entry_point(ep, params = nil)
+                puts "Plugin Entry Point: #{ep}" if conf[:debug]
+                keep_going = true
+                @plugins.each_value do |plugin|
+                    if plugin.respond_to?(ep)
+                        keep_going &= params.nil? ? plugin.send(ep) : plugin.send(ep, params)
+                    end
+                end
+                keep_going
+            end
+
+            # Applies replacements
+            #
+            # The replacements are stored in conf[options][replacements][moment]
+            # and are provided as command line paramters.
+            #
+            # format represents the string in which the replacements are done
+            # moment determines which replacements are done (on old or new name)
+            def do_replacements(format, moment)
+                begin
+                    replacements = conf[:options][:replacements][moment]
+                rescue NoMethodError
+                    replacements = nil
+                end
+                unless replacements.nil?
+                    replacements.each do |repl|
+                        format.gsub!(repl[:pattern], repl[:replace])
+                    end
+                end
+            end
+        end
+    end
+end

data/lib/absolute_renamer/config.rb

@@ -0,0 +1,40 @@
+require 'yaml'
+
+module AbsoluteRenamer
+    # Class handeling the configuration.
+    class Config
+        class << self
+            # Open and load a Yaml file into the +@conf+ variable.
+            # config_path: path of the file to load.
+            def load(config_path)
+                @conf = YAML::load_file(config_path)
+
+                @conf[:options] ||= {}
+                @conf[:options][:format] ||= '$'
+                @conf[:options][:ext_format] ||= '$'
+            end
+
+            # Returns a configuration value identified by +key+.
+            # If +key+ is ignored, returns the +@conf+ hash.
+            def get(key = nil)
+                return @conf[key] if @conf.has_key?(key)
+                return @conf
+            end
+
+            # Sets a configuration value in the +@conf+ variable.
+            def set(key, value = '')
+                @conf[key] = value
+            end
+
+            # Returns a configuration value identified by +key+.
+            def [](key)
+                @conf[key]
+            end
+
+            # Sets a configuration value in the +@conf+ variable.
+            def []=(key, value)
+                @conf[key] = value
+            end
+        end
+    end
+end

data/lib/absolute_renamer/external.rb

@@ -0,0 +1,56 @@
+require 'absolute_renamer/imodule'
+require 'absolute_renamer/iplugin'
+require 'absolute_renamer/use_config'
+
+module AbsoluteRenamer
+    # Class in charge of loading +modules+ and +plugins+.
+    class External
+        class << self
+            include AbsoluteRenamer::UseConfig
+
+            # Loads the additional and core modules.
+            # The modules list is get from the conf[:modules] variable.
+            # The core modules are loaded after the additional ones.
+            #
+            # See also load
+            def load_modules
+                puts "[Loading modules]" if conf[:debug]
+
+                modules = conf[:modules]
+                load(modules, :modules, 'module.rb') unless modules.nil?
+
+                core_modules = ['case', 'general'].map! { |core_module| File.join('core', core_module) }
+                load(core_modules, :modules, 'module.rb')
+            end
+
+            # Loads the plugins.
+            # The plugins list is get from the conf[:plugins] variable.
+            #
+            # See also load
+            def load_plugins
+                puts "[Loading plugins]" if conf[:debug]
+
+                load(conf[:plugins], :plugins, 'plugin.rb')
+            end
+
+            # Loads an external list (+modules+ or +plugins+)
+            # externals: a list of +externals+ names to load.
+            # type: a symbol defining which type of external to load
+            # file: the filename to require to load the +externals+
+            def load(externals, type, file)
+                ext_dir = conf[:path][type]
+
+                externals.each do |external|
+                    ext_to_load = File.join(ext_dir, external, file)
+                    begin
+                        if require ext_to_load
+                            puts "Loaded: #{ext_to_load}" if conf[:debug]
+                        end
+                    rescue LoadError => e
+                        STDERR.puts(e)
+                    end
+                end
+            end
+        end
+    end
+end

data/lib/absolute_renamer/external/modules/core/case/module.rb

@@ -0,0 +1,31 @@
+module AbsoluteRenamer
+    class CaseModule < AbsoluteRenamer::IModule
+        class << self
+            attr_reader :actions
+        
+            def actions
+                @actions ||= {'*' => :camelize,
+                              '&' => :upper,
+                              '%' => :lower,
+                              '$' => :original
+                             }
+            end
+
+            def camelize(str)
+                str.camelize
+            end
+
+            def original(str)
+                str
+            end
+
+            def lower(str)
+                str.downcase
+            end
+
+            def upper(str)
+                str.upcase
+            end
+        end
+    end
+end

data/lib/absolute_renamer/external/modules/core/general/module.rb

@@ -0,0 +1,126 @@
+module AbsoluteRenamer
+    class GeneralModule < AbsoluteRenamer::IModule
+        def initialize
+            @actions = {'*'  => :file_camelize,
+                        '$'  => :file_original,
+                        '%'  => :file_downcase,
+                        '&'  => :file_upcase,
+                        '\\' => :file_strip,
+                        '#'  => :count
+                       }
+
+            @case_filters = ['(\\\\\*)',    # \*
+                             '(\\\\\$)',    # \$
+                             '(\\\%)',      # \%
+                             '(\\\&)',      # \&
+                             '(\\\\\\\)',   # \\
+                             '(\*)',        # *
+                             '(\$)',        # $
+                             '(%)',         # %
+                             '(&)',         # &
+                             '(\\\)'        # \
+                            ]
+
+            # matches strings like [42-43] [42-] [*42-43] [42;43] etc...
+            @part_filters = ['(\[(.)?(\d+)(((-)(\d+)?)|((;)(\d+)))?\])']
+
+            # matches counters like # ### #{2} ##{2;42} or [length-42]
+            @misc_filters = ['(/)', '(#+(\{.*\})?)', '(\[length(--?\d+)?\])']
+
+            @filters = @case_filters + @part_filters + @misc_filters
+        end
+
+        def interpret(file, infos, type)
+            if (infos[0].length == 1)
+                self.method(@actions[infos[0][0].chr]).call(file, infos, type)
+            elsif (infos[0][1..6] == 'length')
+                self.length(file, infos, type)
+            elsif (infos[0][0].chr == '[')
+                self.file_part(file, infos, type)
+            elsif (infos[0][0].chr == '#')
+                self.count(file, infos, type)
+            else
+                infos[0][1].chr
+            end
+        end
+
+        def file_camelize(file, infos, type)
+            file.send(type).camelize
+        end
+
+        def file_original(file, infos, type)
+            file.send(type)
+        end
+
+        def file_downcase(file, infos, type)
+            file.send(type).downcase
+        end
+
+        def file_upcase(file, infos, type)
+            file.send(type).upcase
+        end
+
+        def file_strip(file, infos, type)
+            file.send(type).strip
+        end
+
+        def file_part(file, infos, type)
+            matched = infos[0].match(/(\[([^\d])?(\d+)(((;)(\d+))|((-)(\d+)?))?\])/)
+
+            modifier = matched[2]
+            x = matched[3].to_i - 1
+            y = matched[7] || matched[10]
+            y = y.to_i unless y.nil?        
+            action = matched[6] || matched[9]
+
+            str = file.send(type)
+
+            if (action == '-')
+                y -= 1 unless y.nil?
+                y ||= str.length
+                val = str[x..y]
+            elsif (action == ';')
+                val = str[x, y]
+            else
+                val = str[x].chr
+            end
+
+            unless modifier.nil?
+                mp = CaseModule.method(CaseModule.actions[modifier])
+                val = mp.call(val)
+            end
+            val
+        end
+
+        def count(file, infos, type)
+            matched = infos[0].match(/(#+)(\{((-?\d+)(;(-?\d+)?)?)?\})?/)
+            @counter ||= []
+            @last ||= nil
+            @current ||= 0
+
+            @current = 0 if @last != file
+            @current += 1 if @last == file
+
+            start = matched[4] || 1
+            step = matched[6] || 1
+            start = start.to_i
+            step = step.to_i
+
+            @counter[@current] ||= {:start => start,
+                                    :step => step,
+                                    :current => start - step
+                                   }
+
+            @counter[@current][:current] += @counter[@current][:step]
+            @last = file
+            val = @counter[@current][:current].to_s.rjust(matched[1].length, '0')
+            val.gsub!(/(0+)-/, '-\1')
+            val
+        end
+
+        def length(file, infos, type)
+            matched = infos[0].match(/\[length(-(-?\d+))?\]/)
+            file.name.length - matched[2].to_i
+        end
+    end
+end

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,102 @@
+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,
+                      :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
+
+        # 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
+
+        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
+    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

data/lib/absolute_renamer/use_config.rb

@@ -0,0 +1,11 @@
+require 'absolute_renamer/config'
+
+module AbsoluteRenamer
+    # Module that provide configuration usage.
+    module UseConfig
+        # Returns the configuration class
+        def conf
+            @conf ||= AbsoluteRenamer::Config
+        end
+    end
+end

data/lib/absolute_renamer/with_children.rb

@@ -0,0 +1,22 @@
+require 'absolute_renamer/use_config'
+
+module AbsoluteRenamer
+    # Class allowing childs listing.
+    class WithChildren
+        include AbsoluteRenamer::UseConfig
+
+        @children = []
+        class << self
+            attr_reader :children
+
+            # Inheritance callback.
+            # When a class inherit from a WithChildren class, it is added to
+            # the childs list of this class.
+            # This list is available as the +children+ attribute.
+            def inherited(by)
+                @children << by
+                by.instance_variable_set(:@children, [])
+            end
+        end
+    end
+end

data/test/absolute_renamer_test.rb

@@ -1,7 +1,7 @@
 require 'test_helper'
 
 class AbsoluterenamerTest < Test::Unit::TestCase
-  should "probably rename this file and start testing for real" do
-    flunk "hey buddy, you should probably rename this file and start testing for real"
+  should "be true" do
+    assert true
   end
 end

data/test/config_test.rb

@@ -0,0 +1,45 @@
+require 'test_helper'
+
+class ConfigTest < Test::Unit::TestCase
+  context "The Config instance" do
+    
+    should "exist" do
+      assert_not_nil AbsoluteRenamer::Config
+    end
+    
+    should "raise ENOENT if config file not found" do
+      assert_raise(Errno::ENOENT) do
+        AbsoluteRenamer::Config.load('a file that must not be found')
+      end  
+    end
+
+    should "not raise ENOENT if config file is found" do
+      assert_nothing_raised(Errno::ENOENT) do
+        AbsoluteRenamer::Config.load('conf/absrenamer/absrenamer.conf')
+      end
+    end
+
+    context "with a loaded config file" do
+      setup do
+        AbsoluteRenamer::Config.load('conf/absrenamer/absrenamer.conf')
+      end
+
+      should "be able to set and get config options" do
+        AbsoluteRenamer::Config.set(:test_key, :test_val)
+        assert_equal(:test_val, AbsoluteRenamer::Config.get(:test_key))
+      end
+
+      should "be able to set and get a config option with the nil key" do
+        AbsoluteRenamer::Config.set(nil, :test_val)
+        assert_equal(:test_val, AbsoluteRenamer::Config.get(nil))
+      end
+
+      should "be able to set config options using []" do
+        AbsoluteRenamer::Config[:test_key] = :test_val
+        assert_equal(:test_val, AbsoluteRenamer::Config[:test_key])
+      end
+      
+    end
+
+  end
+end

data/test/file_info_test.rb

@@ -0,0 +1,71 @@
+require 'test_helper'
+
+class FileInfoTest < Test::Unit::TestCase
+  context "A FileInfo instance" do
+    context "loaded with some/path/to/a_file.txt" do
+
+      setup do
+        @pwd = Dir.pwd
+        @fileinfo = AbsoluteRenamer::FileInfo.new('some/path/to/a_file.txt')
+      end
+
+      should "have as name : a_file" do
+        assert_equal('a_file', @fileinfo.name)
+      end
+
+      should "have as dir_path : pwd/some/path/to" do
+        assert_equal(@pwd + '/some/path/to', @fileinfo.dir_path)
+      end
+
+      should "have as path : some/path/to/a_file.txt" do
+        assert_equal('some/path/to/a_file.txt', @fileinfo.path)
+      end
+
+      should "have as real_path : pwd/some/path/to/a_file.txt" do
+        assert_equal(@pwd + '/some/path/to/a_file.txt', @fileinfo.real_path)
+      end
+
+      should "have as ext : txt" do
+        assert_equal('txt', @fileinfo.ext)
+      end
+
+      should "have as dir : false" do
+        assert_equal(false, @fileinfo.dir)
+      end
+
+    end
+
+    context "loaded with lib/absolute_renamer" do
+
+      setup do
+        @pwd = Dir.pwd
+        @fileinfo = AbsoluteRenamer::FileInfo.new('lib/absolute_renamer')
+      end
+
+      should "have as name : absolute_renamer" do
+        assert_equal('absolute_renamer', @fileinfo.name)
+      end
+
+      should "have as dir_path : pwd/lib" do
+        assert_equal(@pwd + '/lib', @fileinfo.dir_path)
+      end
+
+      should "have as path : lib/absolute_renamer" do
+        assert_equal('lib/absolute_renamer', @fileinfo.path)
+      end
+
+      should "have as real_path : pwd/lib/absolute_renamer" do
+        assert_equal(@pwd + '/lib/absolute_renamer', @fileinfo.real_path)
+      end
+
+      should "have as ext : nil" do
+        assert_nil @fileinfo.ext
+      end
+
+      should "have as dir : true" do
+        assert_equal(true, @fileinfo.dir)
+      end
+
+    end
+  end
+end

data/test/file_test.rb

@@ -0,0 +1,33 @@
+require 'test_helper'
+
+# Called LibFileTest instead of FileTest to avoid ruby errors
+class LibFileTest < Test::Unit::TestCase
+  context "The File class" do
+
+    should "return txt for a_file.txt when calling extname" do
+      assert_equal("txt", File.extname('a_file.txt'))
+    end
+    
+    should "return an empty string for a_file when calling extname" do
+      assert_equal("", File.extname('a_file'))
+    end
+
+    should "return tar.gz for archive.tar.gz when calling extname with 2 dots" do
+      assert_equal("tar.gz", File.extname('archive.tar.gz', 2))
+    end
+    
+    should "return gz for archive.tar.gz when calling extname" do
+      assert_equal("gz", File.extname('archive.tar.gz'))
+    end
+
+    should "return an empty string for . and a_file. when calling extname" do
+      assert_equal("", File.extname('.'))
+      assert_equal("", File.extname('fichier.'))
+    end
+
+    should "return test for .test when calling extname" do
+      assert_equal("test", File.extname('.test'))
+    end
+
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: simonc-AbsoluteRenamer
 version: !ruby/object:Gem::Version 
-  version: 0.9.1
+  version: 0.9.2
 platform: ruby
 authors: 
 - Simon COURTOIS
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-09-21 00:00:00 -07:00
+date: 2009-09-22 00:00:00 -07:00
 default_executable: absrenamer
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -34,10 +34,36 @@ extra_rdoc_files:
 files: 
 - .document
 - .gitignore
+- AbsoluteRenamer.gemspec
 - LICENSE
 - README.rdoc
 - Rakefile
 - VERSION
+- bin/absrenamer
+- conf/absrenamer/absrenamer.conf
+- lib/absolute_renamer.rb
+- lib/absolute_renamer/config.rb
+- lib/absolute_renamer/external.rb
+- lib/absolute_renamer/external/modules/core/case/module.rb
+- lib/absolute_renamer/external/modules/core/general/module.rb
+- lib/absolute_renamer/external/parsers/core/general/parser.rb
+- lib/absolute_renamer/external/parsers/interactive/parser.rb
+- lib/absolute_renamer/external/parsers/listing/parser.rb
+- lib/absolute_renamer/external/plugins/interactive/plugin.rb
+- lib/absolute_renamer/external/plugins/listing/plugin.rb
+- lib/absolute_renamer/file_info.rb
+- lib/absolute_renamer/imodule.rb
+- lib/absolute_renamer/iparser.rb
+- lib/absolute_renamer/iplugin.rb
+- lib/absolute_renamer/libs/file.rb
+- lib/absolute_renamer/libs/string.rb
+- lib/absolute_renamer/parser.rb
+- lib/absolute_renamer/use_config.rb
+- lib/absolute_renamer/with_children.rb
+- test/absolute_renamer_test.rb
+- test/config_test.rb
+- test/file_info_test.rb
+- test/file_test.rb
 - test/test_helper.rb
 has_rdoc: false
 homepage: http://github.com/simonc/AbsoluteRenamer
@@ -68,4 +94,7 @@ specification_version: 3
 summary: AbsoluteRenamer is a very powerful tool that helps files and directories renaming using the Krename syntax.
 test_files: 
 - test/absolute_renamer_test.rb
+- test/config_test.rb
+- test/file_info_test.rb
+- test/file_test.rb
 - test/test_helper.rb