AbsoluteRenamer 0.9.0

data/Rakefile

@@ -0,0 +1,20 @@
+%w[rubygems rake rake/clean fileutils newgem rubigen].each { |f| require f }
+require File.dirname(__FILE__) + '/lib/absolute_renamer'
+
+$hoe = Hoe.new('AbsoluteRenamer', AbsoluteRenamer::VERSION) do |p|
+    p.developer('Simon COURTOIS', 'happynoff@free.fr')
+    p.changes              = p.paragraphs_of("ChangeLog", 0..1).join("\n\n")
+    p.rubyforge_name       = p.name
+
+    p.extra_dev_deps = [
+        ['newgem', ">= #{::Newgem::VERSION}"]
+    ]
+
+    p.clean_globs |= %w[**/.DS_Store tmp *.log]
+    path = (p.rubyforge_name == p.name) ? p.rubyforge_name : "\#{p.rubyforge_name}/\#{p.name}"
+    p.remote_rdoc_dir = File.join(path.gsub(/^#{p.rubyforge_name}\/?/,''), 'rdoc')
+    p.rsync_args = '-av --delete --ignore-errors'
+end
+
+require 'newgem/tasks' # load /tasks/*.rake
+Dir['tasks/**/*.rake'].each { |t| load t }

data/bin/absrenamer

@@ -0,0 +1,54 @@
+#!/usr/bin/env ruby
+
+#
+# = Synopsis
+#
+# Does a batch renaming on files and directories
+#
+# = Usage
+#
+# absrenamer [options] [file]...
+#
+# = Description
+#
+# AbsoluteRenamer is a very powerful tool that helps files and directories
+# renaming using the Krename syntax.
+#
+# It is extendable by adding new command line parsers,
+# new renaming modules and plugins.
+#
+# Parsers allow to add new command line options.
+# Modules allow to add new renaming patterns (like ID3 tags).
+# Plugins allow to add new features like file listing instead of renaming.
+#
+# = Exemple
+#
+#   absrenamer-f '[1;2]_[*4-]' *.mp3
+#   # => takes the first two characters of the original name
+#   #    and Camelizes from the fourth to the end.
+#
+# = Copyright (c) 2009 Simon COURTOIS
+# Licensed under the GNU Public License
+
+$:.unshift File.dirname(__FILE__) << '/../lib'
+
+require 'absolute_renamer'
+require 'absolute_renamer/config'
+require 'absolute_renamer/parser'
+require 'absolute_renamer/external'
+
+config_path = File.dirname(__FILE__)+'/../conf/absrenamer/absrenamer.conf'
+config_path = '/etc/absrenamer/absrenamer.conf' if File.exists?('/etc/absrenamer/absrenamer.conf')
+custom_conf = '~/.absrenamerrc'
+
+AbsoluteRenamer::Config.load(config_path)
+AbsoluteRenamer::Config.load(custom_conf) if File.exists? custom_conf
+
+AbsoluteRenamer::Parser.parse_cmd_line
+
+AbsoluteRenamer::External.load_modules
+AbsoluteRenamer::External.load_plugins
+
+AbsoluteRenamer::Processor.load_plugins
+AbsoluteRenamer::Processor.create_names_list
+AbsoluteRenamer::Processor.do_renaming

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,119 @@
+$:.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.0"
+    
+    # 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
+                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