AbsoluteRenamer 1.1.0 → 1.1.1

data/lib/absolute_renamer/core-packages/core-case/module.rb

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

data/lib/absolute_renamer/core-packages/core-general/module.rb

@@ -1,131 +1,109 @@
 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 = [
-                pattern('(\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+)?))?\])/)
-
-            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
-
-            val ||= ''
-
-            modify val, matched[2]
-        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
+  class GeneralModule < AbsoluteRenamer::IModule
+    def initialize
+      @case_filters = [
+        /\\\*/,   # \*
+        /\\\$/,   # \$
+        /\\%/,    # \%
+        /\\&/,    # \&
+        /\\\\/,   # \\
+        /\*/,     # *
+        /\$/,     # $
+        /%/,    # %
+        /&/,    # &
+        /\\/    # \
+      ]
+
+      # matches strings like [42-43] [42-] [*42-43] [42;43] etc...
+      @part_filters = [
+        pattern('(\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][0].chr == '#')
+        count(file, infos)
+      elsif (infos[0].length == 1)
+        file_case(file, infos[0], type)
+      elsif (infos[0][1..6] == 'length')
+        length(file, infos)
+      elsif (infos[0][0].chr == '[')
+        file_part(file, infos, type)
+      else
+        infos[0][1].chr
+      end
+    end
+
+    def file_case(file, modifier, type)
+      file_info = file.send(type)
+
+      if modifier.match /\\/
+        file_info.strip!
+      else
+        file_info = modify(file_info, modifier)
+      end
+
+      file_info
+    end
+
+    def file_part(file, infos, type)
+      matched = infos[0].match(/(\[([^\d])?(\d+)(((;)(\d+))|((-)(\d+)?))?\])/)
+
+      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
+
+      val ||= ''
+
+      modify val, matched[2]
+    end
+
+    def count(file, infos)
+      matched = infos[0].match(/(#+)(\{((-?\d+)(;(-?\d+)?)?)?\})?/)
+      @counter ||= []
+      @last  ||= nil
+
+      @current = (@last != file) ? 0 : @current + 1
+
+      @counter[@current] ||= {
+        :value   => (matched[4] || 1).to_i,
+        :step  => (matched[6] || 1).to_i,
+      }
+
+      val = @counter[@current][:value].to_s.rjust(matched[1].length, '0')
+      val.gsub!(/(0+)-/, '-\1')
+
+      @counter[@current][:value] += @counter[@current][:step]
+      @last = file
+
+      val
+    end
+
+    def length(file, infos)
+      matched = infos[0].match(/\[length(-(-?\d+))?\]/)
+      file.name.length - matched[2].to_i
+    end
+  end
 end

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

@@ -1,78 +1,89 @@
 # 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
+  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('-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('-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
+      parser.on('-f', '--format FORMAT',
+                'Format string used as model') do |format|
+        options[:format] = format
+        @format_given = true
 
-                raise "Format cannot contain the / character." if format.match(/\//)
-            end
+        raise "Format cannot contain the / character." if format.match(/\//)
+      end
 
-            parser.on('-x', '--ext-format FORMAT',
-                      'Format string used as model for the extension') do |format|
-                options[:ext_format] = format
+      parser.on('-x', '--ext-format FORMAT',
+                'Format string used as model for the extension') do |format|
+        options[:ext_format] = format
 
-                raise "Format cannot contain the / character." if format.match(/\//)
-            end
+        raise "Format cannot contain the / character." if format.match(/\//)
+      end
 
-            parser.on('-R', '--recursive',
-                      'Rename files in subdirectories recursively') do
-                options[:rec] = true
-            end
+      parser.on('--no-ext', '--no-extension', 'Removes the extension') do
+        options[:no_ext] = true
+      end
 
-            parser.on('--maxdepth N', Integer, 'Maximum recursion depth') do |depth|
-                options[:maxdepth] = depth
-            end
+      parser.on('--dots N', Integer, 'Number of dots to get file extension') do |dots|
+        options[:dots] = dots
+      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('-R', '--recursive',
+                'Rename files in subdirectories recursively') do
+        options[:rec] = true
+      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
+      parser.on('--maxdepth N', Integer, 'Maximum recursion depth') do |depth|
+        options[:maxdepth] = depth
+      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
+      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] ||= {
+        :before => [],
+        :after  => []
+      }
+      options[:replacements][moment] << {
+        :type  => pattern.class,
+        :pattern => pattern,
+        :replace => replace
+      }
     end
-end
+  end
+end

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

@@ -1,20 +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
+  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('-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
+      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