rfs 0.1

data/lib/regexp.rb

@@ -0,0 +1,56 @@
+class PrepareRegexp
+  def initialize(pattern)
+    @s = pattern
+  end
+
+  #def new_regexp(pattern)
+    #begin
+      #Regexp.new(pattern)
+  #end
+
+  def create(ignore_case, verbose, roman, &b)
+    begin
+      c = verbose ? VerboseRegexp : Regexp
+      o = ignore_case ? Regexp::IGNORECASE : nil
+      s = roman ? @s.gsub('(roman)', "(#{Regexp.ROMAN_PATTERN})") : @s 
+      r = c.new s, o
+      r.result_proc = b if verbose
+      r
+    rescue
+      b.call :error, "Error parsing regular expression:\n#{$!}"
+      nil
+    end
+  end
+
+  def self.each(options)
+    options[:filter].each do |f|
+      if f.regexp.is_a? PrepareRegexp
+        f.regexp = yield :filter, f.regexp
+      end
+    end
+    options.each do |k, v|
+      if v.is_a? PrepareRegexp
+        options[k] = yield k, v
+      end
+    end
+  end
+end
+
+class VerboseRegexp < Regexp
+  attr_accessor :k
+  attr_accessor :result_proc
+
+  def match(*a)
+    m = super
+    s = "MatchData breakdown for #{@k}: " 
+    if m
+      s += "\n" + m.display_breakdown
+    else
+      s += 'no match'
+    end
+    @result_proc.call :match, s
+    m
+  end
+end
+
+

data/lib/rename_functions.rb

@@ -0,0 +1,142 @@
+
+module RenameFunctions
+protected
+  def rename_replace
+    rename_each_match do |file, md|
+      subst(file, md, opt(:replace, String))
+    end
+  end
+  
+  def rename_name_source
+    rename_each_match do |file, md, path|
+      subst(file, md, opt(:source, NameSource).name(file, md, path))
+    end
+  end
+
+  def rename_add
+    if opt(:add, Numeric) > 0
+      opt(:file_provider, Provider::File::Base).reverse
+    end
+    rename_each_match do |file, md|
+      int = active_capture(md).to_i rescue int = active_capture(md) rescue int = 0
+      subst(file, md, (int + opt(:add, Numeric)).to_s)
+    end
+  end
+
+  def rename_count
+    count = 0
+    rename_each_match do |file, md|
+      count += 1
+      subst(file, md, count.to_s)
+    end
+  end
+
+  def rename_from_full_name
+    r = opt(:pattern, Regexp)
+    rename_each_match do |file, md, path|
+      fn = File.expand_path(File.join(path, file))
+      m = r.match(fn)
+      verbose {"match on fullname: #{m.display}"}
+      if m
+        subst(file, md, active_capture(m))
+      else
+        [:message, "no match in full name: #{fn}"]
+      end
+    end
+  end
+
+  def rename_move_up
+    rename_each_match do |file, md, path|
+      p = File.split(path).first
+      unless p == '\\' 
+        [:full_path, File.join(p, file)]
+      else
+        nil
+      end
+    end
+  end
+
+  def rename_roman
+    s = @options[:search]
+    if s.is_a? Regexp
+      @options[:search] = s.interpolate_roman 
+      verbose {"search: #{@options[:search].to_s}"}
+    end
+    rename_each_match do |file, md|
+      subst(file, md, active_capture(md).toggle_roman) if active_capture(md).length > 0 
+    end
+  end
+
+  def rename_mark_change
+    prev = ''
+    rename_each_match do |file, md|
+      m = active_capture(md)
+      unless prev == m
+        prev = m
+        subst(file, opt(:replace_pattern, Regexp).match(file), opt(:replace_text, String))
+      end
+    end
+  end
+  
+  def rename_tape_numbers
+    rename_each_match do |file, md|
+      t = active_capture(md)
+      n = t.to_i * 2 + (/a/i =~ t[-1,1] ? -1 : 0)
+      n += 2 if n < 1
+      subst(file, md, n.to_s)
+    end
+  end
+
+  def rename_capitalize  
+    al = opt(:always_lower, Array) rescue %w{ vol
+                                mp3 wav txt avi nfo pdf rar
+                                zip rb ape sfk mpg rm qt doc }
+    l = opt(:lower, Array) rescue String.LOWER
+    dc = opt(:double_cap) rescue String.DOUBLE_CAP
+    ca = opt(:cap_after) rescue String.CAP_AFTER  
+    sp = opt(:split_pattern) rescue String.SPLIT_PATTERN
+    u = opt(:upper) rescue String.UPPER
+                                
+    rename_each_match do |file, md|
+      o = active_capture(md)
+      r = o.title_case(:always_lower => al,
+                   :lower => l,
+                   :double_cap => dc,
+                   :cap_after => ca,
+                   :split_pattern => sp,
+                   :upper => u)
+      subst(file, md, r)
+    end
+  end
+
+  def rename_fill
+    fillRE = opt :fill, Regexp
+    fillText = ''
+    verbose {"fill pattern: #{fillRE.to_s}"}
+    rename_each do |file, md|
+      if md or fillText
+        m = active_capture(md) if md
+        if md and m.length > 0 and not (fillRE and fillRE.match(file))
+          fillText = m
+          [:message, "source: #{file}"]
+        else
+          md = fillRE.match(file)
+          if md
+            [:rename, subst(file, md, fillText)]
+          else
+            [:message, "* No capture to fill * #{file}"] 
+          end
+        end
+      end
+    end
+  end
+
+  def rename_remove
+    rename_each_match do |file, md, path|
+      :delete
+    end
+  end
+end
+
+
+

data/lib/renamer.rb

@@ -0,0 +1,210 @@
+require 'innate/mkdirs'
+require 'innate/roman'
+require 'innate/titlecase'
+require 'providers'
+require 'rename_functions'
+require 'stringio'
+require 'errors'
+require 'options'
+require 'filters'
+require 'regexp'
+require 'namesource'
+
+class Renamer
+  def run(name, options, &block)
+    @result_proc = block
+    @options = options
+    method(name).call
+  end
+
+  def rename_functions
+    methods.grep(/^rename_/)
+  end
+    
+  include RenameFunctions
+  include Options
+
+protected
+
+  def subst(src, matchdata, repl)
+    return src unless matchdata
+    matchdata.sub repl, options[:capture_num]
+  end
+
+  def result(type, t, path = nil, file = nil)
+    @result_proc.call type, t.to_s, path, file
+  end
+  
+  def verbose
+    @result_proc.call(:verbose, yield) if @options[:verbose]
+  end
+
+  def actual_rename(o, n)
+    File.mkdirs File.split(n).first
+    if File.directory? n
+      raise DirectoryExistsError.new("Can't overwrite an existing directory.")
+    else
+      File.rename(o, n)
+    end
+  end
+
+  def actual_delete(fn)
+    if File.directory? fn
+      Dir.delete fn
+    else
+      File.delete fn
+    end
+  end
+
+  def confirm(path, oldfn, newfn, full_path)
+    return true if @confirm == :all || !@options[:confirm]
+    exists = @options[:force] && already_exists?(path, oldfn, newfn, full_path)
+    @confirm = opt(:confirm, Proc, Method).call path, oldfn, newfn, full_path, exists, (@confirm || :yes)
+    verbose {"confirmation: #{@confirm}"}
+    case @confirm
+    when :all, :yes
+      return true
+    when :no
+      return false
+    when :cancel
+      throw :cancel
+    end
+  end
+
+  def dest_file(path, newfn, full_path)
+    if full_path
+      fn = newfn
+    else
+      fn = File.join(path, newfn)
+    end 
+  end
+
+  def active_capture(matchdata)
+    n = @options[:capture_num] || 1
+    matchdata[n] || matchdata[0]
+  end
+
+  def already_exists?(path, oldfn, newfn, full_path)
+    fn = dest_file(path, newfn, full_path)
+    if File.exists? fn
+      fn.downcase != File.join(path, oldfn).downcase
+    else
+      false
+    end
+  end
+  
+  def rename(path, oldfn, newfn, full_path = false)
+    old_full = File.join path, oldfn 
+    verbose {"rename: `#{old_full}` -> `#{newfn}`"}
+    unless oldfn == newfn or (full_path and old_full == newfn)
+      t = newfn
+      fn = dest_file path, newfn, full_path
+      if !@options[:force] and already_exists?(path, oldfn, newfn, full_path)
+        result :fileerror, 'File already exists', path, oldfn
+      elsif @options[:action] == :commit
+        if confirm path, oldfn, newfn, full_path
+          begin
+            actual_rename old_full, fn
+          rescue => e
+            result :fileerror, "#{e.class}: #{e.message}", path, oldfn
+          else
+            result :ok, t, path, oldfn
+          end
+        else
+          result :skipped, oldfn, path, oldfn
+        end
+      else
+        result :ok, t, path, oldfn
+      end
+    end
+  end      
+
+  def delete(path, file)
+    fn = File.join path, file
+    verbose {"delete: `#{fn}` "}
+    if @options[:action] == :commit
+      if confirm path, file, '<<deleted>>', false
+        begin
+          actual_delete fn
+        rescue => e
+          result :fileerror, "#{e.class}: #{e.message}", path, file
+        else
+          result :ok, "<<#{file}>>", path, file
+        end
+      else
+        result :skipped, file, path, file
+      end
+    else
+      result :ok, "<<#{file}>>", path, file
+    end
+  end
+  
+  def rename_each
+    if @options[:action] == :list
+      @options[:file_provider].each do |path, file|
+        opt_if(:filter, Filter) do |filter|
+          unless filter.filter path, file
+            verbose { "filtered: #{file}" }
+            next
+          end
+        end
+        result :ok, "#{file}#{(File.directory?(File.join(path, file)) ? '/' : '')}", path, file
+      end
+    elsif @options[:action] == :commit || @options[:action] == :preview
+      catch :cancel do
+        search = opt :search, Regexp
+        filter = opt_if(:filter, Filter)
+        @options[:file_provider].each do |path, file|
+          verbose {'-------------------------'}
+          if filter; unless filter.filter path, file
+              verbose { "filtered: #{file}" }
+              next
+          end end
+          verbose {"file: #{File.join path, file}"}
+          md = search.match(file)
+          verbose {"match: #{md.display}"}
+          begin
+            action, text = r = yield(file, md, path)
+            verbose {"action: #{action.inspect}"}
+            if action == :rename
+              rename path, file, text if text
+            elsif action == :full_path
+              rename path, file, text, true if text
+            elsif action == :message
+              result :message, text, path, file
+            elsif r == :delete
+              delete path, file
+            elsif r
+              result :fileerror, "Unrecognised response: #{r.inspect}", path, file
+            end
+          rescue => e
+            if e.is_a? RenamerError or (!$DEBUG and !$TESTING)
+              t = file
+              if md
+                t = md.display
+              end
+              result :fileerror, "Error: #{e.class} on #{t}\n#{e.message}", path, file
+            else
+              raise e
+            end
+          end
+        end
+      end
+    else
+      raise ActionError.new
+    end
+  end
+  
+  def rename_each_match
+    rename_each do |file, md, path|
+      r = yield(file, md, path) if md
+      if r.is_a? String
+        [:rename, r]
+      else
+        r
+      end
+    end
+  end
+
+end
+

data/lib/results.rb

@@ -0,0 +1,83 @@
+class CollectResults
+  attr_accessor :verbose, :quiet, :silent, :sideways, :lineways, :sorted, :list
+  attr_accessor :out 
+  attr_reader :results
+  
+  def initialize(out_io)
+    @verbose = false
+    @quiet = false
+    @silent = false
+    @sideways = false
+    @lineways = false
+    @sorted = false
+    @list = false
+    
+    @out = out_io
+    
+    @results = Hash.new do |h, k|
+      case k when :fileerror, :ok, :skipped
+        h[k] = Hash.new {|hh, kk| hh[kk] = []}
+      else
+        h[k] = []
+      end
+    end
+  end
+    
+  def output(mode, text, path = nil, file = nil)
+    if @verbose
+      @out.puts "#{mode}: #{text}"
+    else
+      case mode when :ok, :skipped
+        @results[mode][path] << text
+      when :fileerror
+        @results[mode][path] << "#{file}: #{text}"
+      else
+        @results[mode] << text 
+      end
+    end
+  end
+
+  def display
+    result = ""
+    unless @silent
+      m = @sideways ? :rows : :columns
+      ok = 0
+      skipped = 0
+      errors = 0
+      @results.each do |mode, value|
+        case mode when :fileerror, :ok, :skipped
+          value.collect.sort.each do |k, v|
+            case mode when :ok: ok += v.length
+            when :skipped: skipped += v.length
+            when :fileerror: errors += v.length
+            end
+            s = "\n#{File.expand_path(k)}"
+            s += ": #{mode.to_s.upcase} - #{v.length} files" unless @quiet or @list
+            @out.puts s
+            v = v.sort if @sorted
+            if @lineways
+              @out.puts v.join("\n")
+            else
+              @out.puts v.send(m, 80)
+            end
+          end
+        else
+          @out.puts "\n#{mode.to_s.upcase}"
+          if @lineways
+            @out.puts value.join("\n")
+          else
+            @out.puts value.send(m, 80)
+          end
+        end
+      end
+      unless @quiet
+        @out.print "\nOK: #{ok}" if ok.nonzero?
+        @out.print "\nSKIPPED: #{skipped}" if skipped.nonzero?
+        @out.print "\nERRORS: #{errors}" if errors.nonzero?
+        @out.puts "\nTOTAL: #{ok + skipped + errors}"
+      end
+    end
+  end
+end
+
+