crackup 1.0.0 → 1.0.1

data/HISTORY

@@ -1,4 +1,11 @@
 Crackup Release History
 
+Version 1.0.1 (11/21/2006)
+  * Fix broken handling of symbolic links.
+  * Expand relative paths before backing up.
+  * Win32: If gpg.exe isn't in the system path, look for it at the path
+    specified in the HKCU\Software\GNU\GnuPG\gpgProgram registry key (if the key
+    exists) before failing.
+
 Version 1.0.0 (11/16/2006)
   * First release.

data/README

@@ -13,12 +13,12 @@ transferred to the remote location over a variety of protocols, including FTP.
 Additional storage drivers can easily be written in Ruby.
 
 Author::    Ryan Grove (mailto:ryan@wonko.com)
-Version::   1.0.0
+Version::   1.0.1
 Copyright:: Copyright (c) 2006 Ryan Grove. All rights reserved.
 License::   New BSD License (http://opensource.org/licenses/bsd-license.php)
 Website::   http://wonko.com/software/crackup
 
 == Dependencies
 
-- Ruby 1.8.5+
+- Ruby 1.8.4+
 - GPG 1.4.2+ (if you want to encrypt your backups)

data/bin/crackup

@@ -4,7 +4,7 @@
 # <tt>crackup -h</tt> for usage information.
 #
 # Author::    Ryan Grove (mailto:ryan@wonko.com)
-# Version::   1.0.0
+# Version::   1.0.1
 # Copyright:: Copyright (c) 2006 Ryan Grove. All rights reserved.
 # License::   New BSD License (http://opensource.org/licenses/bsd-license.php)
 #
@@ -13,7 +13,7 @@ require 'crackup'
 require 'optparse'
 
 APP_NAME      = 'crackup'
-APP_VERSION   = '1.0.0'
+APP_VERSION   = '1.0.1'
 APP_COPYRIGHT = 'Copyright (c) 2006 Ryan Grove (ryan@wonko.com). All rights reserved.'
 APP_URL       = 'http://wonko.com/software/crackup'
 
@@ -116,7 +116,7 @@ module Crackup
     @options[:from] = []
     
     while filename = ARGV.shift
-      @options[:from] << filename.chomp('/')
+      @options[:from] << File.expand_path(filename)
     end
   end
   

data/bin/crackup-restore

@@ -4,7 +4,7 @@
 # See <tt>crackup-restore -h</tt> for usage information.
 #
 # Author::    Ryan Grove (mailto:ryan@wonko.com)
-# Version::   1.0.0
+# Version::   1.0.1
 # Copyright:: Copyright (c) 2006 Ryan Grove. All rights reserved.
 # License::   New BSD License (http://opensource.org/licenses/bsd-license.php)
 #
@@ -13,7 +13,7 @@ require 'crackup'
 require 'optparse'
 
 APP_NAME      = 'crackup-restore'
-APP_VERSION   = '1.0.0'
+APP_VERSION   = '1.0.1'
 APP_COPYRIGHT = 'Copyright (c) 2006 Ryan Grove (ryan@wonko.com). All rights reserved.'
 APP_URL       = 'http://wonko.com/software/crackup'
   
@@ -134,7 +134,7 @@ module Crackup
   
   # List remote files if the --list option was given.
   if @options[:list]
-    puts get_list(@remote_files).sort
+    puts get_list(@remote_files)
     exit
   end
 

data/lib/crackup.rb

@@ -1,19 +1,21 @@
-ENV['PATH'] = "#{File.dirname(__FILE__)};#{ENV['PATH']}"
-
 require 'crackup/errors'
-require 'crackup/dirobject'
+require 'crackup/directory_object'
 require 'crackup/driver'
-require 'crackup/fileobject'
-require 'tempfile'
+require 'crackup/file_object'
+require 'crackup/symlink_object'
+require 'find'
+require 'tmpdir'
 require 'zlib'
 
 module Crackup
 
-  GPG_DECRYPT = 'echo :passphrase | gpg --batch --quiet --no-tty --no-secmem-warning --cipher-algo aes256 --compress-algo bzip2 --passphrase-fd 0 --output :output_file :input_file'
-  GPG_ENCRYPT = 'echo :passphrase | gpg --batch --quiet --no-tty --no-secmem-warning --cipher-algo aes256 --compress-algo bzip2 --passphrase-fd 0 --output :output_file --symmetric :input_file'
+  GPG_DECRYPT = 'echo :passphrase | :gpg --batch --quiet --no-tty --no-secmem-warning --cipher-algo aes256 --compress-algo bzip2 --passphrase-fd 0 --output :output_file :input_file'
+  GPG_ENCRYPT = 'echo :passphrase | :gpg --batch --quiet --no-tty --no-secmem-warning --cipher-algo aes256 --compress-algo bzip2 --passphrase-fd 0 --output :output_file --symmetric :input_file'
   
   attr_accessor :driver, :local_files, :options, :remote_files
   
+  @gpg_path = nil
+  
   # Reads _infile_ and compresses it to _outfile_ using zlib compression.
   def self.compress_file(infile, outfile)
     File.open(infile, 'rb') do |input|
@@ -52,10 +54,11 @@ module Crackup
     File.delete(outfile) if File.exist?(outfile)
 
     gpg_command = String.new(GPG_DECRYPT)
-    gpg_command.gsub!(':input_file', escapeshellarg(infile))
+    gpg_command.gsub!(':gpg',         find_gpg())
+    gpg_command.gsub!(':input_file',  escapeshellarg(infile))
     gpg_command.gsub!(':output_file', escapeshellarg(outfile))
-    gpg_command.gsub!(':passphrase', escapeshellarg(@options[:passphrase]))
-    
+    gpg_command.gsub!(':passphrase',  escapeshellarg(@options[:passphrase]))    
+
     unless system(gpg_command)
       raise Crackup::EncryptionError, "Unable to decrypt file: #{infile}"
     end
@@ -70,9 +73,10 @@ module Crackup
     File.delete(outfile) if File.exist?(outfile)
 
     gpg_command = String.new(GPG_ENCRYPT)
-    gpg_command.gsub!(':input_file', escapeshellarg(infile))
+    gpg_command.gsub!(':gpg',         find_gpg())
+    gpg_command.gsub!(':input_file',  escapeshellarg(infile))
     gpg_command.gsub!(':output_file', escapeshellarg(outfile))
-    gpg_command.gsub!(':passphrase', escapeshellarg(@options[:passphrase]))
+    gpg_command.gsub!(':passphrase',  escapeshellarg(@options[:passphrase]))
     
     unless system(gpg_command)
       raise Crackup::EncryptionError, "Unable to encrypt file: #{infile}"
@@ -85,12 +89,64 @@ module Crackup
     abort "#{APP_NAME}: #{message}"
   end
   
-  # Wraps _arg_ in single quotes, escaping any single quotes contained therein,
-  # thus making it safe for use as a shell argument.
+  # Wraps _arg_ in single quotes (double quotes in Windows), escaping any quotes
+  # contained therein, thus making it safe for use as a shell argument.
   def self.escapeshellarg(arg)
-    return "'#{arg.gsub("'", "\\'")}'"
+    if RUBY_PLATFORM =~ /mswin32/
+      return "\"#{arg.gsub('"', '\\"')}\""
+    else
+      return "'#{arg.gsub("'", "\\'")}'"
+    end
   end
   
+  # Returns the name of the GnuPG executable to use. First we search for +gpg+
+  # or <tt>gpg.exe</tt> in the path. On Windows, if it isn't in the system path,
+  # we try to find a pointer to it in the registry. If everything fails, a
+  # Crackup::Error is raised.
+  def self.find_gpg
+    # Don't bother finding gpg again if we've already found it.
+    return @gpg_path unless @gpg_path.nil?
+  
+    # First, check to see if gpg is in the path.
+    if RUBY_PLATFORM =~ /mswin32/
+      path_dirs = ENV['PATH'].split(';')
+      filename  = 'gpg.exe'
+    else
+      path_dirs = ENV['PATH'].split(':')
+      filename  = 'gpg'
+    end
+    
+    Find.find(*path_dirs) do |path|
+      return @gpg_path = filename if File.executable?(File.join(path, filename))
+    end
+    
+    # Okay, it's not in the path. Unix users are screwed, but if we're on
+    # Windows, we'll make a last-ditch attempt to find it by checking for its
+    # registry key.
+    if RUBY_PLATFORM =~ /mswin32/
+      # Bail out if we can't load the Win32::Registry library.
+      unless require('win32/registry')
+        raise Crackup::Error, 'GnuPG not found.'
+      end
+      
+      # Try to read the GnuPG registry key.
+      begin
+        gpg_path = nil
+        Win32::Registry.open(Win32::Registry::HKEY_CURRENT_USER,
+            'Software\GNU\GnuPG') {|reg| gpg_path = reg.read_s('gpgProgram') }
+      rescue => e
+        raise Crackup::Error, 'GnuPG not found.'
+      end
+      
+      if File.executable?(gpg_path)
+        return @gpg_path = "\"#{gpg_path}\""
+      end
+    end
+    
+    # No luck. Bail out.
+    raise Crackup::Error, 'GnuPG not found.'
+  end
+
   # Gets an array of files in the remote file index whose local paths match
   # _pattern_.
   def self.find_remote_files(pattern)
@@ -103,8 +159,7 @@ module Crackup
         next
       end
 
-      next unless file.is_a?(Crackup::DirectoryObject)
-      files += file.find(pattern)
+      files += file.find(pattern) if file.is_a?(Crackup::DirectoryObject)
     end
     
     return files
@@ -117,16 +172,14 @@ module Crackup
   
     if files.is_a?(Hash)
       files.each_value {|value| list += get_list(value) }
-    elsif files.is_a?(Crackup::DirectoryObject)
-      list += get_list(files.children)
-    elsif files.is_a?(Crackup::FileObject)
-      list << files.name 
+    elsif files.is_a?(Crackup::FileSystemObject)
+      list += files.to_s.split("\n")
     end
     
-    return list
+    return list.sort
   end
 
-  # Gets a Hash of Crackup::FileSystemObjects representing the files and
+  # Gets a Hash of {Crackup::FileSystemObject}s representing the files and
   # directories on the local system in the locations specified by the array of
   # filenames in <tt>options[:from]</tt>.
   def self.get_local_files
@@ -143,13 +196,8 @@ module Crackup
         end
       end
       
-      if File.directory?(filename)
-        debug "--> #{filename}"
-        local_files[filename] = Crackup::DirectoryObject.new(filename)
-      elsif File.file?(filename)
-        debug "--> #{filename}"
-        local_files[filename] = Crackup::FileObject.new(filename)
-      end
+      debug "--> #{filename}"
+      local_files[filename] = Crackup::FileSystemObject.from(filename)
     end
     
     return local_files
@@ -227,10 +275,24 @@ module Crackup
   # Creates a new temporary file in the system's temporary directory and returns
   # its name. All temporary files will be deleted when the program exits.
   def self.get_tempfile
-    tempfile = Tempfile.new('.crackup')
-    tempfile.close
+    # We would use Ruby's tempfile library here, but for some reason it
+    # sometimes deletes temp files before the program exits, which can cause all
+    # kinds of problems.
+    i = -1
+    
+    while tempfile = File.join(Dir.tmpdir(),
+        ".crackup.#{Process.pid}.#{i += 1}") do
+      break unless File.exist?(tempfile)
+    end
     
-    return tempfile.path
+    at_exit do 
+      begin
+        File.delete(tempfile)
+      rescue => e
+      end
+    end
+    
+    return tempfile
   end
 
   # Gets an Array of Crackup::FileSystemObjects representing files and
@@ -253,12 +315,8 @@ module Crackup
         # Add to the list all updated files contained in the directory and its 
         # subdirectories.
         updated += get_updated_files(localfile.children, remotefile.children)
-      elsif localfile.is_a?(Crackup::FileObject) && 
-          remotefile.is_a?(Crackup::FileObject)
-        # Add the file to the list if the local file has been modified.
-        unless localfile.file_hash == remotefile.file_hash
-          updated << localfile
-        end
+      elsif localfile != remotefile
+        updated << localfile
       end
     end
     
@@ -279,17 +337,13 @@ module Crackup
   # Deletes each Crackup::FileSystemObject specified in the _files_ array from
   # the remote location.
   def self.remove_files(files)
-    files.each do |file|
-      file.remove
-    end
+    files.each {|file| file.remove }
   end
   
   # Uploads each Crackup::FileSystemObject specified in the _files_ array to the
   # remote location.
   def self.update_files(files)
-    files.each do |file|
-      file.update
-    end
+    files.each {|file| file.update }
   end
   
   # Brings the remote file index up to date with the local one.

data/lib/crackup/{dirobject.rb → directory_object.rb}

@@ -1,16 +1,17 @@
-require 'crackup/fsobject'
+require 'crackup/fs_object'
 
 module Crackup
 
   # Represents a directory on the local filesystem. Can contain any number of
   # Crackup::FileSystemObjects as children.
   class DirectoryObject
+    include Enumerable
     include FileSystemObject
 
     attr_reader :children
 
     #--
-    # Public Class Methods
+    # Public Instance Methods
     #++
     
     def initialize(name)
@@ -20,12 +21,24 @@ module Crackup
 
       super(name)
 
-      refresh_children
+      refresh_children()
     end
     
-    #--
-    # Public Instance Methods
-    #++
+    # Compares the specified Crackup::DirectoryObject to this one. Returns
+    # +true+ if the directories and all their children are the same, +false+
+    # otherwise.
+    def ==(directory)
+      return false unless directory.name == @name      
+      return directory.all?{|child| child == @children[child.name] }
+    end
+    
+    def [](key)
+      return @children[key]
+    end
+    
+    def each
+      @children.each {|child| yield child }
+    end
     
     # Gets an array of files contained in this directory or its children whose
     # local filenames match _pattern_.
@@ -38,8 +51,9 @@ module Crackup
           next
         end
         
-        next unless child.is_a?(Crackup::DirectoryObject)
-        files << result if result = child.find(pattern)
+        if child.is_a?(Crackup::DirectoryObject)
+          files << result if result = child.find(pattern)
+        end
       end
       
       return files
@@ -54,22 +68,20 @@ module Crackup
         dir.each do |filename|
           next if filename == '.' || filename == '..'
 
-          filename = File.join(dir.path, filename).gsub("\\", "/")
+          path = File.join(dir.path, filename).gsub("\\", "/")
 
           # Skip this file if it's in the exclusion list.
           unless Crackup::options[:exclude].nil?
             next if Crackup::options[:exclude].any? do |pattern|
-              File.fnmatch?(pattern, filename)
+              File.fnmatch?(pattern, path)
             end
           end
 
-          if File.directory?(filename)
-            @children[filename.chomp('/')] = Crackup::DirectoryObject.new(filename)
-          elsif File.file?(filename)
-            @children[filename] = Crackup::FileObject.new(filename)
-          end
+          @children[path] = Crackup::FileSystemObject.from(path)
         end
       end
+      
+      return @children
     end
 
     # Removes the remote copy of this directory and all its children.
@@ -77,12 +89,17 @@ module Crackup
       @children.each_value {|child| child.remove }
     end
 
-    # Restores the remote copy of this directory to the specified local 
-    # <em>path</em>.
+    # Restores the remote copy of this directory to the specified local _path_.
     def restore(path)
       @children.each_value {|child| child.restore(path) }
     end
     
+    def to_s
+      childnames = []
+      @children.each_value {|child| childnames << child.to_s }
+      return childnames.join("\n")
+    end
+    
     # Uploads this directory and all its children to the remote location.
     def update
       @children.each_value {|child| child.update }

data/lib/crackup/{fileobject.rb → file_object.rb}

@@ -1,4 +1,4 @@
-require 'crackup/fsobject'
+require 'crackup/fs_object'
 require 'digest/sha2'
 require 'fileutils'
 
@@ -18,18 +18,25 @@ module Crackup
       super(filename)
       
       # Get the file's SHA256 hash.
-      digest = Digest::SHA256.new()
+      digest = Digest::SHA256.new
       
       File.open(filename, 'rb') do |file|
-        until file.eof? do
-          digest << file.read(1048576)
+        while buffer = file.read(1048576) do
+          digest << buffer
         end
       end
 
       @file_hash = digest.hexdigest()
       @url       = "#{Crackup.driver.url}/crackup_#{@name_hash}"
     end
-    
+
+    # Compares the specified Crackup::FileObject to this one. Returns +false+ if
+    # _file_ is different, +true+ if _file_ is the same. The comparison is
+    # performed using an SHA256 hash of the file contents.
+    def ==(file)
+      return file.name == @name && file.file_hash == @file_hash
+    end
+
     # Removes this file from the remote location.
     def remove
       Crackup.debug "--> #{@name}"

data/lib/crackup/fs_object.rb

@@ -0,0 +1,43 @@
+require 'digest/sha2'
+
+module Crackup
+  
+  # Represents a filesystem object on the local filesystem.
+  module FileSystemObject
+    attr_reader :name, :name_hash
+    
+    #--
+    # Public Class Methods
+    #++
+    
+    # Returns an instance of the appropriate FileSystemObject subclass to
+    # represent _path_.
+    def self.from(path)
+      return Crackup::SymlinkObject.new(path) if File.symlink?(path)
+      return Crackup::DirectoryObject.new(path) if File.directory?(path)
+      return Crackup::FileObject.new(path) if File.file?(path)
+      
+      raise Crackup::Error, "Unsupported filesystem object: #{path}"
+    end
+    
+    #--
+    # Public Instance Methods
+    #++
+    
+    def initialize(name)
+      @name      = name.chomp('/')
+      @name_hash = Digest::SHA256.hexdigest(name)
+    end
+    
+    def ==(fs_object); end
+    def remove; end
+    def restore(path); end
+    
+    def to_s
+      return @name
+    end
+    
+    def update; end
+  end
+
+end

data/lib/crackup/symlink_object.rb

@@ -0,0 +1,66 @@
+require 'crackup/fs_object'
+require 'fileutils'
+
+module Crackup
+
+  # Represents a symbolic link on the local filesystem.
+  class SymlinkObject
+    include FileSystemObject
+
+    attr_reader :file_hash, :target, :url
+  
+    #--
+    # Public Instance Methods
+    #++
+
+    def initialize(linkname)
+      unless File.symlink?(linkname)
+        raise ArgumentError, "#{linkname} is not a symbolic link"
+      end
+      
+      super(linkname)
+      
+      @target = File.readlink(linkname)
+    end
+    
+    # Compares the specified Crackup::SymlinkObject to this one. Returns +true+
+    # if they're the same, +false+ if _symlink_ is different.
+    def ==(symlink)
+      return symlink.name == @name && symlink.target == @target
+    end
+    
+    # Removes this link from the remote location. This is actually a noop, since
+    # link data is just stored in the index.
+    def remove
+      Crackup.debug "--> #{@name}"
+    end
+
+    # Restores the remote copy of this link to the local path specified by
+    # _path_.
+    def restore(path)
+      path     = path.chomp('/') + '/' + File.dirname(@name).delete(':')
+      linkname = path + '/' + File.basename(@name)
+
+      Crackup.debug "--> #{linkname}"
+      
+      # Create the path if it doesn't exist.
+      unless File.directory?(path)
+        begin
+          FileUtils.mkdir_p(path)
+        rescue => e
+          raise Crackup::Error, "Unable to create local directory: #{path}"
+        end
+      end
+      
+      # Create the link.
+      File.symlink(@target, linkname)
+    end
+    
+    # Uploads this link to the remote location. This is actually a noop, since
+    # link data is just stored in the index.
+    def update
+      Crackup.debug "--> #{@name}"
+    end
+  end
+
+end

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.9.0
 specification_version: 1
 name: crackup
 version: !ruby/object:Gem::Version 
-  version: 1.0.0
-date: 2006-11-15 00:00:00 -08:00
+  version: 1.0.1
+date: 2006-11-20 00:00:00 -08:00
 summary: Crackup is a pretty simple, pretty secure remote backup solution for folks who want to keep their data securely backed up but aren't particularly concerned about bandwidth usage.
 require_paths: 
 - lib
@@ -33,12 +33,13 @@ files:
 - bin/crackup-restore
 - lib/crackup
 - lib/crackup.rb
-- lib/crackup/dirobject.rb
+- lib/crackup/directory_object.rb
 - lib/crackup/driver.rb
 - lib/crackup/drivers
 - lib/crackup/errors.rb
-- lib/crackup/fileobject.rb
-- lib/crackup/fsobject.rb
+- lib/crackup/file_object.rb
+- lib/crackup/fs_object.rb
+- lib/crackup/symlink_object.rb
 - lib/crackup/drivers/file.rb
 - lib/crackup/drivers/ftp.rb
 - LICENSE

data/lib/crackup/fsobject.rb

@@ -1,18 +0,0 @@
-require 'digest/sha2'
-
-module Crackup
-  
-  # Represents a filesystem object on the local filesystem.
-  module FileSystemObject
-    attr_reader :name, :name_hash
-    
-    def initialize(name)
-      @name      = name.chomp('/')
-      @name_hash = Digest::SHA256.hexdigest(name)
-    end
-    
-    def remove; end
-    def restore(local_path); end
-  end
-
-end