rrename 0.2.0

data/rrename.rb

@@ -0,0 +1,897 @@
+#!/usr/bin/ruby
+#
+# RenameFiles in Ruby/GTK 
+#
+# Copyright (c) 2005 Jens Lincke
+# 
+# Last edited: 2005-06-27 23:52:15 by jens on wh11-618.st.uni-magdeburg.de
+#
+# This program is free software.
+# You can distribute/modify this program under the terms of
+# the GNU LGPL, Lesser General Public License version 2.1.
+#
+
+require 'optparse'
+require 'optparse/time'
+require 'ostruct'
+require 'pp'
+
+require 'pango'
+
+require 'gtk2'
+require 'gnome2'
+require 'libglade2'
+
+require 'yaml'
+require 'thread'
+
+#
+# standoff markup to inline marup
+#
+
+class Standoff
+
+  def initialize(text)
+    @index_tag= []
+    @text= text
+  end
+
+  def add(index, tag)
+    @index_tag << [index, tag]
+    nil
+  end
+
+  def add_tag(start_index, end_index, tag, attr="")
+    if attr.size == 0 then
+      add(start_index, "<"+tag +">")
+    else
+      add(start_index, "<"+tag +" "+attr + ">")
+    end
+    add(end_index, "</"+tag+">")
+    nil
+  end
+
+  def markup
+    @index_tag.sort!
+    offset= 0
+    markup= @text.clone
+    @index_tag.each { |index, tag|
+      markup.insert(index + offset, tag)
+      offset +=  tag.size
+    }
+    markup.gsub!("&", "&amp;")
+    return markup
+  end
+
+end
+
+class CommandProcessor
+  attr_accessor :history
+
+  def initialize(renameFiles)
+    @renameFiles= renameFiles
+    @history= []
+    @redo_list= []
+    @log= renameFiles.log
+    @appbar= @renameFiles.appbar
+    @running= false
+  end
+
+  def exec(command_prototype)
+    if not @redo_list.empty? then
+      @redo_list= []
+    end
+    command= command_prototype.clone
+    @appbar.push(command.to_s)
+    command.exec
+    @history.push command 
+  end
+  
+  def undo
+    if not @history.empty? then
+      command= @history.pop
+      @appbar.push("undo " + command.to_s)
+      command.undo
+      @redo_list.push command 
+    else
+      @log.p "nothing to undo"
+    end
+  end
+
+  def redo
+    if not @redo_list.empty? then
+      command= @redo_list.pop
+      @appbar.push("redo " + command.to_s)
+      command.redo
+      @history.push(command)
+    else
+      @log.p "nothing to redo"
+      @appbar.push("nothing to redo")
+    end
+  end
+end
+
+class RenameCommand 
+
+  def initialize(renameFiles)
+    @renameFiles= renameFiles
+    @log= renameFiles.log
+  end
+  
+  def exec
+    @fileset= @renameFiles.fileset
+    self.redo
+  end
+  
+  def redo
+    @fileset.rename_changed()
+  end 
+
+  def undo
+    @fileset.undo_rename()
+  end 
+  
+  def to_s
+    return "rename files"
+  end
+  
+end
+
+class ReplaceCommand 
+    
+  def initialize(renameFiles)
+    @renameFiles= renameFiles
+    @log= renameFiles.log
+  end
+  
+  def exec
+    @fileset= @renameFiles.fileset
+    @replaceSchema= @renameFiles.replaceschema
+    self.redo
+  end
+
+  def redo
+    @fileset.file_history_push
+    @log.p self.to_s
+    @fileset.replace(@replaceSchema)
+  end
+  
+  def undo
+    @log.p "undo " + self.to_s
+    @fileset.file_history_pop
+  end
+
+  def to_s
+    "replace pattern in files"
+  end
+end
+
+
+class EditCommand 
+    
+  def initialize(renameFiles, file, edit)
+    @renameFiles= renameFiles
+    @log= renameFiles.log
+    @file= file
+    @edit= edit
+  end
+  
+  def exec
+    @undo_name= @file.name
+    self.redo
+  end
+
+  def redo
+    @log.p self.to_s
+    @file.name= @edit
+  end
+  
+  def undo
+    @log.p "undo "+  self.to_s
+    @file.name= @undo_name
+  end
+ 
+  def to_s
+    "edit filename"
+  end
+end
+
+
+class AddFilesCommand 
+    
+  def initialize(renameFiles, files)
+    @renameFiles= renameFiles
+    @log= renameFiles.log
+    @files= files
+  end
+  def exec
+    @files.each {|filename|
+      file= GLib.filename_to_utf8(filename)
+      @renameFiles.fileset.add(file)  
+    }      
+  end
+
+  def redo
+  end
+  
+  def undo
+  end
+
+  def to_s
+    return "add files to list"
+  end
+end
+
+
+class RemoveSelectedCommand 
+    
+  def initialize(renameFiles)
+    @renameFiles= renameFiles
+    @fileset= @renameFiles.fileset
+    @log= renameFiles.log
+  end
+  
+  def exec
+    @removed= @fileset.remove_selected()
+  end
+
+  def undo
+    @log.p "undo remove files from list: "  
+    @fileset.addEntries(@removed)
+  end
+  
+  def redo
+  end
+
+  def to_s
+    return "remove files from list"
+  end
+end
+
+class ReplaceSchema
+  attr_accessor :pattern        # replace this regexp pattern
+  attr_accessor :substitute     # with this
+  attr_accessor :initializeCode # eval this before iteration over file set
+  attr_accessor :iterationCode  # eval this for each match
+  attr_accessor :name  
+
+  def initialize(name, pattern, substitute, initializeCode, iterationCode)
+    @name           = name      
+    @pattern        = pattern      
+    @substitute     = substitute   
+    @initializeCode = initializeCode
+    @iterationCode  = iterationCode
+  end
+
+  def file
+    @name.gsub(" ","_")+"_rs.yaml"
+  end
+end
+
+
+class FileSet 
+  attr_accessor :regex
+  attr_accessor :renameFiles
+  attr_accessor :entries
+  attr_accessor :log
+ 
+  def initialize(renameFiles)
+    @renameFiles= renameFiles
+    @log= renameFiles.log
+    @entries= Hash.new
+  end
+  
+  def markup(regex_str)
+    @regex= Regexp.new(regex_str)
+    @renameFiles.treestore.each do |model,path,iter|
+      model.signal_emit("row-changed", path, iter)
+    end
+  rescue RegexpError 
+    @log.p "RegexpError: " + regex_str
+  end
+
+  def add(file)
+    addToNode(file, nil)
+  end
+  
+  def addToNode(file, node)
+    filename= GLib.filename_from_utf8(file)
+    fileStat= File.stat(filename)
+    filename= GLib.filename_from_utf8(file)
+    if File.exist?(filename) then
+      @log.p "added #{file}"
+ 
+      if node then
+          addEntry(FileEntry.new(file, self), node)
+      else
+        addEntry(FileEntry.new(file, self))
+      end  
+
+    else
+      @log.p file + " don't exist"
+    end
+  end
+
+  def addEntryToNode(entry, parent)
+    if(parent) then
+      entry.parent= parent
+    end
+    entry.iter= @renameFiles.treestore.append((parent ? parent.iter : nil))
+    entry.iter[0]= entry
+  end
+
+  def includes?(entry)
+    return @entries[entry.expand_path]
+  end
+
+  def addEntry(entry)
+    if not includes?(entry) then 
+      @entries[entry.expand_path]=entry
+      parent= @entries[File.expand_path(entry.path)]
+      addEntryToNode(entry, parent)
+    end
+  end
+    
+  def save_eval(aString, aBinding) 
+    begin
+      return eval(aString, aBinding)
+    rescue  SyntaxError, NameError
+      @log.p "error in eval: " + aString 
+      return nil
+    end
+  end
+  
+  def replace(replaceSchema)
+    file=nil
+    aBinding= binding
+    save_eval(replaceSchema.initializeCode, aBinding)
+    @regex= Regexp.new(replaceSchema.pattern)
+    @renameFiles.treestore.each do |model,path,iter|
+      file= iter[0]
+      if file.match(@regex) then
+        save_eval(replaceSchema.iterationCode, aBinding)
+        substitute= save_eval('"'+replaceSchema.substitute+'"', aBinding)
+        file.replace(@regex,substitute) if substitute
+        model.signal_emit("row-changed", path, iter)
+      end 
+    end
+  end
+  
+  def file_history_pop
+    @renameFiles.treestore.each do |model,path,iter|
+      file= iter[0]
+      oldname= file.name
+      file.pop_name
+      model.signal_emit("row-changed", path, iter) 
+    end
+  end
+
+  def file_history_push
+    @renameFiles.treestore.each do |model,path,iter|
+      file= iter[0]
+      file.push_name
+    end
+  end
+
+  def remove_selected()
+    remove_list= []
+    # iter k�nnen nicht direkt entfernt werden
+    removed= []
+    @renameFiles.treeview.selection.selected_each {|model, path, iter| 
+      remove_list << iter
+      removed << iter[0]
+    }
+    remove_list.each { |iter|
+      remove_iter(iter)
+    }
+    return removed
+  end
+  
+  def remove_iter(iter)
+    if @renameFiles.treestore.iter_is_valid? iter then
+      @log.p "remove #{iter[0].name} from list"
+      @entries.delete iter[0].expand_path
+        
+      @renameFiles.treestore.remove(iter) 
+    end
+  end
+  
+  def addEntries(entries)
+    entries.each { |entry| addEntry(entry) }
+  end
+
+  def undo_rename
+    @renameFiles.treestore.each { |model,path,iter|
+      file= iter[0]
+      if file.undo_rename then
+        model.signal_emit("row-changed", path, iter)
+      end
+    }
+  end
+
+  def rename_changed
+    @renameFiles.treestore.each { |model,path,iter|
+      file= iter[0]
+      if file.changed? then
+        file.rename
+	model.signal_emit("row-changed", path, iter)
+      else
+        file.fake_rename
+      end
+    }
+  end
+end
+
+class FileEntry
+  attr_accessor :name
+  attr_accessor :parent
+  attr_accessor :iter
+
+  def initialize(filename, fileset, parent=nil)
+    @path=     File.dirname(filename)
+    @name=     File.basename(filename)
+    @old_name= @name.clone
+    @colors=   ["red", "green", "blue", "orange"]
+    @fileset=  fileset
+    @name_history=   []
+    @rename_history= []
+    @parent=   parent
+    @log=      @fileset.log
+  end
+  
+  def mark_color(string, color)
+    '<span foreground=\""'+ color + '\"">'+ string + '</span>'
+  end
+  
+  def changed?() 
+    return @name != @old_name
+  end
+
+  def full_path
+    path + "/" + @name
+  end
+  
+  def expand_path
+    File.expand_path(full_path)
+  end
+  
+  def path
+    if @parent then
+      return @parent.full_path
+    else
+      return @path
+    end
+  end
+    
+  def colorize(regex)
+    standoff= Standoff.new(@name)
+    @name.scan(regex) { |m|
+      match= Regexp.last_match 
+      (0...(match.length)).each {|i| 
+        color= @colors[ i % @colors.size]
+	if(match.begin(i) != match.end(i)) then
+	  standoff.add_tag(match.begin(i), match.end(i),
+			   "span","foreground=\""+ color + "\"")
+	end
+      }
+    }
+    standoff.markup
+  end
+
+  def markup()
+    if @fileset.regex then
+      colorize(@fileset.regex); 
+    else
+      Standoff.new(@name).markup
+    end 
+  end
+  
+  def undo_rename
+    old_name_name= @rename_history.pop
+    if old_name_name then
+      old_name_name
+      @old_name= old_name_name[0]
+      @name= old_name_name[1]
+      from= GLib.filename_from_utf8(@path + "/" + @old_name)
+      to= GLib.filename_from_utf8(@path + "/" + @name)
+      
+      if not File.exists?(from) or not File.exists?(to) then
+        @log.p "rename #{to} to #{from} back" 
+        begin
+          File.rename(to, from)
+        rescue
+          @log.p "error: couldn't undo rename #{to} to #{from}"
+        end
+      else
+        @log.p "couldn't undo rename #{to} to #{from}"
+      end
+      @log.p "undo rename #{from} to #{to}" 
+      return true
+    else
+      return false
+    end
+  end
+  
+  def fake_rename
+    @rename_history.push(nil)
+  end
+  
+  def rename
+    from= GLib.filename_from_utf8(path + "/" + @old_name)
+    to= GLib.filename_from_utf8(path + "/" + @name)
+    if File.exists?(from) and not File.exists?(to) then
+      begin
+        @rename_history.push([@old_name, @name])
+        File.rename(from, to)
+        @log.p "rename #{from} to #{to}" 
+      rescue
+        @log.p "couldn't rename #{from} to #{to}"
+        return
+      end
+      @old_name= @name.clone
+    else
+      @log.p "couldn't rename #{from} to #{to}"
+      @rename_history.push(nil)
+    end
+  end
+
+  def replace(regex, string)
+    if regex.match(@name) then
+      @name.gsub!(regex, string)
+      return true
+    else
+      return false
+    end
+  end
+
+  def match(regex)
+    return regex.match(@name)
+  end
+
+
+  def push_name
+    @name_history.push(name.clone)
+  end
+  
+  def pop_name
+    if @name_history.empty? then
+      return false
+    else
+      @name= @name_history.pop() 
+    end
+  end
+  
+end
+
+class Log
+
+  def initialize(buffer, bar)
+    @buffer=buffer
+    @bar=bar 
+  end
+
+  def p(line)
+    line
+    @buffer.insert_at_cursor(line +"\n")
+  end  
+end
+
+class RenameFiles
+  TITLE=          "Ruby Rename Files"
+  NAME=           "Rename Files"
+  VERSION=        "0.2.0"
+  CONFDIR=        ".rrename"
+  REPLACESCHEMAS= "replaceschemas.yaml"
+
+  attr_accessor :fileset
+  attr_accessor :entry_replace_this
+  attr_accessor :entry_replace_with
+  attr_accessor :treestore
+  attr_accessor :treeview
+  attr_accessor :options
+  attr_accessor :progressBar
+  attr_accessor :comandProcessor
+  attr_accessor :log
+  attr_accessor :appbar
+  attr_accessor :textview_eval_initialize
+  attr_accessor :textview_eval_iteration
+  attr_accessor :replace_schemas
+
+  def initialize()
+    Gnome::Program.new(RenameFiles::NAME, RenameFiles::VERSION)
+    
+    glade_file= find_in_load_path("/RenameFiles/rrename.glade")
+    glade_file= find_in_load_path("/rrename.glade") if not glade_file 
+    glade_file= File.dirname($0) + "/rrename.glade" if not glade_file 
+    @glade= GladeXML.new(glade_file, nil, "rrename"){|handler| method(handler)}
+    
+    # get widgets from glade 
+    @window=                   @glade.get_widget("appwindow")
+    @appbar=                   @glade.get_widget("appbar")
+    @treeview=                 @glade.get_widget("files_treeview")
+    @filechooser=              @glade.get_widget("filechooser")
+    @entry_replace_this=       @glade.get_widget("pattern_entry")
+    @entry_replace_with=       @glade.get_widget("replace_entry")
+    @log_view=                 @glade.get_widget("log_textview")
+    @textview_eval_initialize= @glade.get_widget("textview_eval_initialize")
+    @textview_eval_iteration=  @glade.get_widget("textview_eval_eachmatch")
+    @settings_menu=            @glade.get_widget("settings1_menu")
+    @replace_schema_name=      @glade.get_widget("replace_schema_name")
+
+    # initialize 
+    @replace_schemas=          Hash.new
+    add_replace_schema(replaceschema)    
+    
+    @logbuffer=          @log_view.buffer
+    @log=                Log.new(@logbuffer, @appbar)
+    @comandProcessor=    CommandProcessor.new(self)
+    @fileset=            FileSet.new(self)
+
+    # initialize commands
+    @renameCommand=      RenameCommand.new(self)
+    @replaceCommand=     ReplaceCommand.new(self) 
+    
+    # customize 
+    @filechooser.select_multiple= true
+    parse_options(ARGV)
+   
+    # setup treeview
+    @treestore=               Gtk::TreeStore.new(Object)
+    @treeview.model=          @treestore
+    @treeview.selection.mode= Gtk::SELECTION_MULTIPLE
+
+    renderer=                 Gtk::CellRendererText.new
+    renderer.editable=        true
+    renderer.editable_set=    true
+    renderer.mode=            Gtk::CellRenderer::MODE_EDITABLE
+    
+    renderer.signal_connect("edited") do |cell, arg1, arg2|
+      file= @treestore.get_iter(arg1)[0]
+      @comandProcessor.exec(EditCommand.new(self, file,arg2))
+    end
+
+    col=      Gtk::TreeViewColumn.new("name", renderer)
+    @treeview.append_column(col)
+    col.set_cell_data_func(renderer) do |col, renderer, model, iter|
+      file=                iter[0]
+      renderer.text=       file.name
+      renderer.markup=     file.markup
+      renderer.background= file.changed? ? "green" : "white"
+    end
+  end
+
+  def show_filechooser
+    @filechooser.set_current_folder(Dir.pwd + "/")
+    ret= @filechooser.run
+    if ret == Gtk::Dialog::RESPONSE_CANCEL
+      @filechooser.hide
+    end
+  end
+
+  def add_files(recursive=false)
+    if not @filechooser.filenames then
+      files= [ @filechooser.filename ] 
+    else
+      files= @filechooser.filenames 
+    end
+    files= expand_filelist_recursive(files, []).sort if recursive 
+    @comandProcessor.exec(AddFilesCommand.new(self,files))
+    @treeview.expand_all
+    @filechooser.hide
+  end
+
+  def add_replace_schema(replaceSchema)
+    @replace_schemas[replaceSchema.name]= replaceSchema
+    update_setting_menu
+  end
+
+  def replaceschema
+    return ReplaceSchema.new(@replace_schema_name.gtk_entry.text,
+                             @entry_replace_this.text,
+                             @entry_replace_with.text,
+                             @textview_eval_initialize.buffer.text,
+                             @textview_eval_iteration.buffer.text)
+  end
+
+  def set_replaceschema(replaceschema)
+    return nil if not replaceschema
+    @replace_schema_name.gtk_entry.text   = replaceschema.name
+    @entry_replace_this.text              = replaceschema.pattern        
+    @entry_replace_with.text              = replaceschema.substitute     
+    @textview_eval_initialize.buffer.text = replaceschema.initializeCode 
+    @textview_eval_iteration.buffer.text  = replaceschema.iterationCode      
+  end
+
+  def confpath
+    GLib.home_dir+"/"+CONFDIR+"/"
+  end
+
+  def save_last_replace_schema
+    save_replace_schema(replaceschema)
+  end
+  
+  def save_replace_schemas
+    file= confpath+REPLACESCHEMAS
+    begin
+      Dir.mkdir(confpath) if not File.exist? confpath
+      file = File.new(file, 'w') 
+      file.write(@replace_schemas.to_yaml)
+    rescue
+      @log.p "can not save "+file
+    end
+  end
+
+  def load_replace_schemas
+    file= confpath+REPLACESCHEMAS
+    begin
+      @replace_schemas= YAML::load(File.open(file))
+      set_replaceschema= @replace_schemas[0]
+    rescue
+      @log.p "can not open "+file
+    end
+    update_setting_menu
+  end
+
+  def update_setting_menu
+    @settings_menu.each { |each|
+      @settings_menu.remove each
+    }
+    @replace_schemas.sort.each { |name, replaceSchema|
+      item= Gtk::MenuItem.new(replaceSchema.name)
+      @settings_menu.append(item)
+      item.signal_connect( "activate" ) {
+        set_replaceschema replaceSchema
+        @comandProcessor.exec(@replaceCommand)
+      }
+    }
+    @settings_menu.show_all
+    
+    @replace_schemas.sort.each { |name, replaceSchema|
+      @replace_schema_name.append_history(0,name)
+    }
+  end
+
+  # 
+  # Event Handler
+  #
+  def on_addfiles(widget)
+    show_filechooser
+  end
+
+  def on_filechooser_addfiles(widget)
+    add_files
+  end
+
+  def on_filechooser_addfiles_recursive(widget)
+    add_files(true)
+  end
+
+  def on_removefiles
+    @comandProcessor.exec(RemoveSelectedCommand.new(self)) 
+  end
+  
+  def on_renamefiles
+    @comandProcessor.exec(@renameCommand) 
+  end
+
+  def on_select_all(widget)
+    @treeview.select_all
+  end
+
+  def on_unselect_all(widget)
+    @treeview.unselect_all
+  end
+
+  def on_undo
+    @comandProcessor.undo 
+  end
+ 
+  def on_redo
+    @comandProcessor.redo 
+  end
+
+  def on_pattern_gnome_entry_changed  
+    Thread.new {
+      @fileset.markup(@entry_replace_this.text)
+    }
+  end
+
+  def on_replacepattern
+    @comandProcessor.exec(@replaceCommand)
+  end
+
+  def on_replace_schema_save
+    add_replace_schema(replaceschema)
+  end
+  
+  def on_replace_schema_delete
+    @replace_schemas.delete(replaceschema.name)
+    update_setting_menu
+  end
+
+  def on_replace_schema_name_changed
+    set_replaceschema @replace_schemas[@replace_schema_name.gtk_entry.text]
+  end
+
+  def on_quit(*widget)
+    save_replace_schemas
+    Gtk.main_quit
+  end
+  
+  def on_about(widget)
+    Gnome::About.new(TITLE, VERSION ,
+                     "Copyright (C) 2005 Jens Lincke",
+                     "RRename - A Rename Files Tool in Ruby",
+                     ["Jens Lincke"], ["Jens Lincke"], nil).show
+  end
+
+  #
+  # private
+  #
+  def expand_filelist_recursive(fileList, result)
+    fileList.each{ |file|
+      result << file
+      if File.directory?(file) then
+        expand_filelist_recursive(Dir[file+"/*"].sort, result) 
+      end
+    }
+    return result
+  end
+
+  def afterStart
+    load_replace_schemas
+    set_replaceschema @replace_schemas["default"]
+    if @options.recursive then
+      @commandArgFiles= expand_filelist_recursive(@commandArgFiles, [])
+    end
+    @comandProcessor.exec(AddFilesCommand.new(self,@commandArgFiles))
+    @treeview.expand_all
+  end
+
+  def parse_options(args)
+    @options= OpenStruct.new
+    @options.verbose=   false
+    @options.print=     true
+    @options.recursive= false
+    @file_list= []
+    
+
+    opts= OptionParser.new do |opts|
+      opts.banner= "Usage: refactorhtml.rb [options] [files]"
+      opts.separator ""
+      opts.separator "Specific options:"
+      
+      opts.on_tail("-h", "--help", "Show this message") do
+        STDERR.puts opts
+        exit
+      end
+      opts.on_tail("-R", "--recursive", "add directories recursively") do
+        @options.recursive= true
+      end
+    end
+    
+    opts.parse!(args)
+
+    @commandArgFiles= []
+    ARGV.each { |f|
+      @commandArgFiles.push(f)
+    }
+  end  
+
+  def find_in_load_path( file )
+    $:.each { |path| 
+      abs_file= path + file
+      return abs_file if File.exist? abs_file
+    }
+    return nil
+  end
+end
+
+@app= RenameFiles.new
+Thread.new {
+   @app.afterStart
+}
+Gtk.main
+
+
+