Piggy 0.4.2.4 → 0.4.3.0

data/lib/piggy-core/upload_info.rb

@@ -5,34 +5,34 @@
 # a set of given files and directories.
 # The size of directories is computed recursively.
 class UploadInfo
-  attr_reader(:bytes, :numFiles, :bytesHash)
+  attr_reader(:bytes, :num_files, :bytes_hash)
   
-  def initialize(filesWithPath)
-    @bytesHash = Hash.new
+  def initialize(files_with_path)
+    @bytes_hash = Hash.new
     @bytes = 0
-    @numFiles = 0
-    add(filesWithPath)
+    @num_files = 0
+    add(files_with_path)
   end
   
   private
 
-  def add(filesWithPath)
-    filesWithPath.each do |fileWithPath|
-      unless @bytesHash.has_key?(fileWithPath)
-	if File.directory?(fileWithPath)
-	  subfiles = Dir.entries(fileWithPath).reject { |e|
-	    e =~ /^\./
-	  }
-	  subfilesWithPath = subfiles.collect { |e|
-	    FilePath.join(fileWithPath, e)
-	  }
-	  add(subfilesWithPath)
-	else
-	  fileSize = File.size(fileWithPath)
-	  @bytesHash[fileWithPath] = fileSize
-	  @bytes = @bytes + fileSize
-	  @numFiles = @numFiles + 1
-	end
+  def add(files_with_path)
+    files_with_path.each do |fileWithPath|
+      unless @bytes_hash.has_key?(fileWithPath)
+        if File.directory?(fileWithPath)
+          subfiles = Dir.entries(fileWithPath).reject { |e|
+            e =~ /^\./
+          }
+          subfiles_with_path = subfiles.collect { |e|
+            FilePath.join(fileWithPath, e)
+          }
+          add(subfiles_with_path)
+        else
+          fileSize = File.size(fileWithPath)
+          @bytes_hash[fileWithPath] = fileSize
+          @bytes = @bytes + fileSize
+          @num_files = @num_files + 1
+        end
       end
     end
   end

data/lib/piggy-core/version.rb

@@ -3,16 +3,16 @@
 
 # Provide release information for Piggy.
 module PiggyVersion
-  def PiggyVersion.versionString
-    '0.4.2-4'
+  def PiggyVersion.version_string
+    '0.4.3-0'
   end
-  def PiggyVersion.copyrightString
-    'Copyright (C) 2008 Sascha D�rdelmann'
+  def PiggyVersion.copyright_string
+    'Copyright (C) 2009 Sascha D�rdelmann'
   end
-  def PiggyVersion.developmentStatus
+  def PiggyVersion.development_status
     'alpha'
   end
-  def PiggyVersion.displayString
-    "#{PiggyVersion.versionString} (#{PiggyVersion.developmentStatus})"
+  def PiggyVersion.display_string
+    "#{PiggyVersion.version_string} (#{PiggyVersion.development_status})"
   end
 end

data/lib/piggy-core/winshell.rb

@@ -6,10 +6,9 @@ require 'singleton'
 # Windows oriented but platform independent file system abstraction.
 class ShellInterface
   def initialize
-    @specialFolderIds = {
+    @special_folder_ids = {
       "ALTSTARTUP" => 0x1d,
       "APPDATA" => 0x1a,
-      "BITBUCKET" => 0xa,
       "COMMONALTSTARTUP" => 0x1e,
       "COMMONAPPDATA" => 0x23,
       "COMMONDESKTOPDIR" => 0x19,
@@ -21,7 +20,6 @@ class ShellInterface
       "COOKIES" => 0x21,
       "DESKTOP" => 0x0,
       "DESKTOPDIRECTORY" => 0x10,
-      "DRIVES" => 0x11,
       "FAVORITES" => 0x6,
       "FONTS" => 0x14,
       "HISTORY" => 0x22,
@@ -29,9 +27,7 @@ class ShellInterface
       "LOCALAPPDATA" => 0x1c,
       "MYPICTURES" => 0x27,
       "NETHOOD" => 0x13,
-      "NETWORK" => 0x12,
       "PERSONAL" => 0x5,
-      "PRINTERS" => 0x4,
       "PRINTHOOD" => 0x1b,
       "PROFILE" => 0x28,
       "PROGRAMFILES" => 0x26,
@@ -44,10 +40,10 @@ class ShellInterface
       "TEMPLATES" => 0x15,
       "WINDOWS" => 0x24
     }
-    initHome
+    init_home
   end
 
-  def initHome
+  def init_home
     @home = ENV['HOME']
     @home = ENV['HOMEPATH'] unless @home
     unless @home
@@ -57,11 +53,11 @@ class ShellInterface
   end
   
   # try to provide a platform independent default
-  def pathForSpecialFolder(name)
+  def path_for_special_folder(name)
     return @home
   end
   
-  def tmpPath
+  def tmp_path
     tmp = ENV['TEMP']
     tmp = ENV['TMP'] unless tmp
     tmp = '/' unless tmp
@@ -69,8 +65,8 @@ class ShellInterface
   end
 
   # platform dependent path (no better default possible)
-  def osPath(pathString)
-    return winPath(pathString)
+  def os_path(pathString)
+    return win_path(pathString)
   end
   
   # for use in commandline execution
@@ -78,29 +74,29 @@ class ShellInterface
     return pathString
   end
   
-  # old name, use osPath instead
-  def winPath(pathString)
+  # old name, use os_path instead
+  def win_path(pathString)
     return pathString
   end
   
   # Get a path string usable by common ruby classes such as Dir and File.
   # Default: convert '\' to '/' on all systems, even on Unix
-  def rubyPath(pathString)
+  def ruby_path(pathString)
     return pathString.gsub(/\\/, separator).gsub(/^~/, @home)
   end
   
-  def pictureDirectory
-    return pathForSpecialFolder("MYPICTURES")
+  def picture_directory
+    return path_for_special_folder("MYPICTURES")
   end
   
-  def desktopDirectory
-    return pathForSpecialFolder("DESKTOPDIRECTORY")
+  def desktop_directory
+    return path_for_special_folder("DESKTOPDIRECTORY")
   end
   
-  def specialFolderListing
-    @specialFolderIds.keys.sort.each do |aFolder|
+  def special_folder_listing
+    @special_folder_ids.keys.sort.each do |aFolder|
       printf "#{aFolder}: "
-      puts "#{pathForSpecialFolder aFolder}"
+      puts "#{path_for_special_folder aFolder}"
     end
   end
   
@@ -109,8 +105,8 @@ class ShellInterface
     return File::SEPARATOR
   end
   
-  def removePath(filenameWithPath)
-    return rubyPath(filenameWithPath).split(separator)[-1]
+  def remove_path(filename_with_path)
+    return ruby_path(filename_with_path).split(separator)[-1]
   end
   
   # Is filename a Windows shortcut? - Default: no file is a shortcut
@@ -119,15 +115,14 @@ class ShellInterface
   end
   
   # Has filename the Extension ext (e. g. ".jpg")
-  def hasExtension?(filename, ext)
+  def has_extension?(filename, ext)
     raise ArgumentError, "Extension missing" if ext.empty?
-    pExt = (ext[0] == '.'[0] ? ext : '.' + ext).downcase
-    dcFilename = filename.downcase
-    return File.basename(dcFilename, pExt) != File.basename(dcFilename)
+    p_ext = (ext[0] == '.'[0] ? ext : '.' + ext).downcase
+    dc_filename = filename.downcase
+    return File.basename(dc_filename, p_ext) != File.basename(dc_filename)
   end
 end
 
-
 # Default access to file system abstraction.
 # A platform dependent singleton will be instantiated.
 class WinShell < ShellInterface
@@ -136,33 +131,79 @@ end
 
 if RUBY_PLATFORM =~ /win32/
   require 'win32ole'
+  require 'win32/dir'
   
   class WinShell < ShellInterface
     
     def initialize
       @shell = WIN32OLE.new('Shell.application')
+      @os_paths = {
+        "ALTSTARTUP" => Dir::ALTSTARTUP,
+        "APPDATA" => Dir::APPDATA,
+        "COMMONALTSTARTUP" => Dir::COMMON_ALTSTARTUP,
+        "COMMONAPPDATA" => Dir::COMMON_APPDATA,
+        "COMMONDESKTOPDIR" => Dir::COMMON_DESKTOPDIRECTORY,
+        "COMMONFAVORITES" => Dir::COMMON_FAVORITES,
+        "COMMONPROGRAMS" => Dir::COMMON_PROGRAMS,
+        "COMMONSTARTMENU" => Dir::COMMON_STARTMENU,
+        "COMMONSTARTUP" =>Dir::COMMON_STARTUP,
+        "COOKIES" => Dir::COOKIES,
+        "DESKTOP" => Dir::DESKTOP,
+        "DESKTOPDIRECTORY" => Dir::DESKTOPDIRECTORY,
+        "FAVORITES" => Dir::FAVORITES,
+        "FONTS" => Dir::FONTS,
+        "HISTORY" => Dir::HISTORY,
+        "INTERNETCACHE" => Dir::INTERNET_CACHE,
+        "LOCALAPPDATA" => Dir::LOCAL_APPDATA,
+        "MYPICTURES" => Dir::MYPICTURES,
+        "NETHOOD" => Dir::NETHOOD,
+        "PERSONAL" => Dir::PERSONAL,
+        "PRINTHOOD" => Dir::PRINTHOOD,
+        "PROFILE" => Dir::PROFILE,
+        "PROGRAMFILES" => Dir::PROGRAM_FILES,
+        "PROGRAMS" => Dir::PROGRAMS,
+        "RECENT" => Dir::RECENT,
+        "SENDTO" => Dir::SENDTO,
+        "STARTMENU" => Dir::STARTMENU,
+        "STARTUP" => Dir::STARTUP,
+        "SYSTEM" => Dir::SYSTEM,
+        "TEMPLATES" => Dir::TEMPLATES,
+        "WINDOWS" => Dir::WINDOWS
+      }
       super
     end
     
-    def pathForSpecialFolder(name)
-      return desktopDirectory if name=="DESKTOP"
-      oleFolder = specialFolder(name)
-      return "" if !oleFolder
-      return pathForFolder(specialFolder(name))
+    def path_for_special_folder(name)
+      win32_utils_path = @os_paths[name]
+      return win32_utils_path ? ruby_path(win32_utils_path) : ""
+    end
+	
+    # Include virtual paths on vindows
+    def special_folder_listing
+      @special_folder_ids.keys.sort.each do |aFolder|
+        puts "#{aFolder}:"
+        puts "\t#{path_for_special_folder aFolder}"
+        puts "\t#{virtual_path_for aFolder}"
+      end
+    end
+      
+    def virtual_path_for(name)
+      ole_folder = special_folder(name)
+      return path_for_folder(ole_folder)
     end
     
     # Is filename a Windows shortcut?
     def link?(filename)
-      return hasExtension?(filename, '.lnk')
+      return has_extension?(filename, '.lnk')
     end
     
     # Get a path string usable by Windows systems.
-    def winPath(pathString)
+    def win_path(pathString)
       return pathString.gsub(separator, "\\")
     end
     
     # Get a path string usable by common ruby classes such as Dir and File.
-    def rubyPath(pathString)
+    def ruby_path(pathString)
       return pathString.gsub(/\\/, separator)
     end
     
@@ -171,52 +212,67 @@ if RUBY_PLATFORM =~ /win32/
       return "\"#{pathString}\""
     end
     
-    #Get the path stored in the Windows shortcut filename. PRE: link?(filename)
-    def getLinkTarget(filename, pathString = Dir.getwd)
-      raise(ArgumentError, "Kein Link") if !link?(filename)
-      filenameOnly = removePath(filename) # avoid errors ignore performance
-      ext = '.' + filenameOnly.split('.')[-1]
-      linkdef = File.basename(filenameOnly,  ext)
-      raise ArgumentError, "Linkname leer" if linkdef.empty?
-      item = getFolderItems(pathString).find { |fi|
-        linkdef == (fi.Name.to_s) }
-      return item ? rubyPath(item.GetLink.Path.to_s) : ''
+    # Get the path stored in the Windows shortcut filename.
+    # PRE: link?(filename)
+    def get_link_target(filename, path_string = Dir.getwd)
+      raise(ArgumentError, "No link") unless link?(filename)
+      puts "Compute shortcut: #{filename}"
+      filename_only = remove_path(filename) # avoid errors ignore performance
+      location = win_path(path_string)
+      ole_folder = shell.NameSpace(location)
+      raise(ArgumentError, "#{path_string} is no folder") unless ole_folder
+      ole_item = get_link_item(filename_only, ole_folder)
+      return '' unless ole_item
+      return ruby_path(ole_item.GetLink.Path.to_s)
     end
     
-    def pathForFolder(folder)
-      current = folder.ParentFolder
-      path = folder.Title
-      while current do
-        title = current.Title
-        if title == "Desktop" # winXP, nicht win2000
-          current = specialFolder("DESKTOPDIRECTORY").ParentFolder
-          title = current.Title
-        end
-        if title =~ /(.):/
-          title.gsub!(/.*\((\w:)\)/, '\1')
-          return title + separator + path
-        end
-        path = title + separator + path
-        current = current.ParentFolder
+    # private; public for better testing only
+
+    def get_link_item(filename, ole_folder)
+      begin
+        return ole_folder.ParseName(filename)
+      rescue Error => ex
+        puts ex.message
       end
-      return path
+      # Fallback to old solution:
+      # Compare filename with all item names in folder.
+      # This didn't work with Vista's shortcut "Sample Pictures"
+      # (The item name in german Vista is "Beispielbilder"
+      # which is not equal to the filename.)
+      ext = '.' + filename.split('.')[-1]
+      linkdef = File.basename(filename,  ext)
+      raise(ArgumentError, "Link name empty") if linkdef.empty?
+      puts "Location: #{path_string}"
+      puts "Shortcut name: #{linkdef}"
+      ole_items = ole_folder.items
+      ole_item_col = (0..ole_items.Count-1).collect { |i| ole_items.item(i) }
+      return ole_item_col.find { |fi| fi.isLink && linkdef == (fi.Name.to_s) }
     end
     
-    # private; public for better testing only
-    
     # My shell is the ole object "Shell" as described in the Windows SDK.
     def shell
       return @shell
     end
     
-    def specialFolder(name)
-      id = @specialFolderIds[name]
+    def special_folder(name)
+      id = @special_folder_ids[name]
       return shell.NameSpace(id)
     end
+	
+    def path_for_folder(folder)
+      current = folder.ParentFolder
+      path = folder.Title
+      while current do
+        title = current.Title
+        path = title + separator + path
+        current = current.ParentFolder
+      end
+      return path
+    end
     
     # Get Directory entries as ole-objects, not as strings!
-    def getFolderItems(directoryPathString)
-      folder = shell.NameSpace(winPath(directoryPathString))
+    def get_folder_items(directoryPathString)
+      folder = shell.NameSpace(win_path(directoryPathString))
       raise "Folderermittlung fehlgeschlagen" if !folder
       items = folder.items
       return (0..items.Count-1).collect { |i| items.item(i) }
@@ -227,21 +283,21 @@ end
 
 if $0 == __FILE__
   def example
-    aShell = WinShell.instance
+    shell = WinShell.instance
     h = "Example 1: WinShell.new.specialFolderListing"
-    hLine = (1..h.size).collect { |c| '*'}
-    puts "#{hLine}\n#{h}\n#{hLine}"
-    aShell.specialFolderListing
+    h_line = (1..h.size).collect { |c| '*'}
+    puts "#{h_line}\n#{h}\n#{h_line}"
+    shell.special_folder_listing
     h = "Example 2. Links on Desktop"
-    hLine = (1..h.size).collect { |c| '*'}
-    puts "#{hLine}\n#{h}\n#{hLine}"
-    desktopDir = aShell.desktopDirectory
-    links = Dir[desktopDir + '/*'].select { |p| aShell.link?(File.basename(p)) }
-    links.each do |l|
-      lName = File.basename l
-      puts "#{lName} => \"#{aShell.getLinkTarget lName, desktopDir}\""
+    h_line = (1..h.size).collect { |c| '*'}
+    puts "#{h_line}\n#{h}\n#{h_line}"
+    desktop_dir = shell.desktop_directory
+    links = Dir[desktop_dir + '/*'].select { |p| shell.link?(File.basename(p)) }
+    links.each do |link_path|
+      link_name = File.basename link_path
+      puts "#{link_name} => \"#{shell.get_link_target link_name, desktop_dir}\""
     end
   end
-  example  
+  example
 end
 

data/lib/piggy-gui/dir_chooser.rb

@@ -7,40 +7,40 @@ require 'piggy-gui/require-fox'
 # Combobox like input field to choose an existing directory
 class DirChooser < Fox::FXHorizontalFrame
   include Fox
-  def initialize(owner, initValue, &onChangedDir)
+  def initialize(owner, init_value, &on_changed_dir)
     super(owner, FRAME_NONE, 0, 0, 0 , 0, 0, 0, 0, 0) {}
     @field = FXTextField.new(self, 32)
     @button = FXButton.new(self, '...')
-    @block = onChangedDir
+    @block = on_changed_dir
     @shell = WinShell.instance
-    connectButtonToField
-    initLayout
-    setPath(initValue)
+    connect_button_to_field
+    init_layout
+    set_path(init_value)
     @field.connect(SEL_COMMAND) {
-      @block.call(getPath)
+      @block.call(get_path)
     }
   end
 
-  def initLayout
+  def init_layout
     @field.setLayoutHints(LAYOUT_LEFT|LAYOUT_FILL_X|LAYOUT_FILL_COLUMN)
   end
 
-  def connectButtonToField
+  def connect_button_to_field
     @button.connect(SEL_COMMAND) {
       dialog = FXDirDialog.new(self, "Choose directory")
       dialog.directory = @field.getText
       unless dialog.execute == 0
-	@field.setText(dialog.directory)
-	@block.call(getPath)
+        @field.setText(dialog.directory)
+        @block.call(get_path)
       end
     }
   end
 
-  def getPath
-    @shell.rubyPath(fox2Ruby(@field.getText))
+  def get_path
+    @shell.ruby_path(fox_2_ruby(@field.getText))
   end
 
-  def setPath(value)
-    @field.setText(ruby2Fox(@shell.osPath(value)))
+  def set_path(value)
+    @field.setText(ruby_2_fox(@shell.os_path(value)))
   end
 end