ftp-ext 0.1.1 → 0.1.3

data/.document

@@ -1,4 +1,4 @@
-README.rdoc
+README.mdown
 lib/**/*.rb
 bin/*
 features/**/*.feature

data/LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2009 Zach Pendleton
+Copyright (c) 2010 Zach Pendleton
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.mdown

@@ -0,0 +1,66 @@
+FTPExt
+======
+A simple gem for copying, synching, and deleting entire folders over FTP. Adds
+two new public methods to Net::FTP &mdash; <code>put\_dir</code> and 
+<code>rmrf\_dir</code>. <code>put\_dir</code> takes a hash of arguments:
+
+*	local - (_string_) The relative or absolute path to the local directory to
+	be copied.
+*	remote - (_string_) The relative or absolute remote path that the local 
+	directory will be copied to.
+*	verbose - (_bool_: defaults to false) Will output progress if set to true.
+*	erase - (_bool_: defaults to false) If set to true, <code>put_dir</code>
+	will overwrite any existing directories (default behavior is to update
+	changed files only).
+*	exclude - (_array_) A list of any files in local directory to be excluded.
+	All file paths in <code>exclude</code> should be relative to <code>local
+	</code>
+
+<code>rmrf\_dir</code> takes two arguments: the path to the remote directory
+to be deleted, and a verbose boolean flag (defaulted to false).
+
+## Usage
+To use FTPExt, require it and use Net::FTP as normal. Because FTPExt requires
+Net::FTP for you, you don't need to include it separately.
+
+	require 'rubygems'
+	require 'ftp-ext'
+	
+	ftp = Net::FTP.new('ftp/server/address')
+	ftp.login('username', 'password')
+	
+	ftp.put_dir(:local => 'path/to/local', :remote => 'path/to/remote')
+
+For example, imagine I have a local directory, 
+<code>/Users/zpendleton/code</code>, that I want to upload on my server to the
+<code>/home/zpendleton</code> directory. I'd run the following command:
+
+	ftp.put_dir('/Users/zpendleton/code', '/home/zpendleton/code')
+
+If the <code>code</code> directory already exists in 
+<code>/home/zpendleton</code>, it will be updated (the script checks the 
+last modified timestamps of all files). If the <code>code</code> directory
+doesn't exist, it will be created. To overwrite the <code>code</code> 
+directory on the server, set the <code>:erase</code> option in 
+<code>put\_dir</code> to <code>true</code>.
+
+To later delete the <code>/home/zpendleton/code</code> directory (in verbose 
+mode), you would use:
+
+	ftp.rmrf_dir('/home/zpendleton/code', true)
+
+To leave verbose mode turned off, you would just omit the second parameter.
+
+## Contributing
+1.	Fork the project.
+2.	Create a branch (<code>git checkout -b my_edit</code>).
+3.	Commit your changes (<code>git commit -am "Added feature"</code>).
+4.	Push to the branch (<code>git push origin my_edit</code>).
+5.	Create an [issue](http://github.com/zpendleton/ftp-ext/issues) with a link 
+	to your branch.
+6.	Kick it old school to [this](http://www.youtube.com/watch?v=jEa1BYBgeQI)
+	while you wait. 
+
+## Copyright
+
+Copyright (c) 2010 Zach Pendleton. See LICENSE for details.

data/ftp-ext.gemspec

@@ -5,22 +5,21 @@
 
 Gem::Specification.new do |s|
   s.name = %q{ftp-ext}
-  s.version = "0.1.1"
+  s.version = "0.1.3"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Zach Pendleton"]
-  s.date = %q{2010-10-12}
-  s.description = %q{ftp-ext adds two methods (sync_dir and put_dir) to Net::FTP to copy and sync whole folders over FTP.}
+  s.date = %q{2010-12-30}
+  s.description = %q{FTPExt adds two methods (put_dir and rmrf_dir) to Net::FTP to copy, sync, and delete whole folders over FTP.}
   s.email = %q{zachpendleton@gmail.com}
   s.extra_rdoc_files = [
-    "LICENSE",
-     "README.rdoc"
+    "LICENSE"
   ]
   s.files = [
     ".document",
      ".gitignore",
      "LICENSE",
-     "README.rdoc",
+     "README.mdown",
      "Rakefile",
      "VERSION",
      "ftp-ext.gemspec",
@@ -32,7 +31,7 @@ Gem::Specification.new do |s|
   s.rdoc_options = ["--charset=UTF-8"]
   s.require_paths = ["lib"]
   s.rubygems_version = %q{1.3.7}
-  s.summary = %q{Folder copying methods for Net::FTP}
+  s.summary = %q{Folder copying and deletion methods for Net::FTP}
   s.test_files = [
     "test/helper.rb",
      "test/test_ftp-ext.rb"
@@ -46,11 +45,11 @@ Gem::Specification.new do |s|
       s.add_development_dependency(%q<shoulda>, [">= 2.11.3"])
       s.add_dependency(%q<ptools>, [">= 1.1.9"])
     else
-      s.add_dependency(%q<shoulda>, [">= 2.11.3"])
+      s.add_development_dependency(%q<shoulda>, [">= 2.11.3"])
       s.add_dependency(%q<ptools>, [">= 1.1.9"])
     end
   else
-    s.add_dependency(%q<shoulda>, [">= 2.11.3"])
+    s.add_development_dependency(%q<shoulda>, [">= 2.11.3"])
     s.add_dependency(%q<ptools>, [">= 1.1.9"])
   end
 end

data/lib/ftp-ext.rb

@@ -1,56 +1,147 @@
-%w{rubygems net/ftp ptools}.each do |lib|
+%w(rubygems net/ftp ptools).each do |lib|
   require lib
 end
 
 module Net
   class FTP
-    
-    def put_dir(local_folder, remote_folder = '.')
-      rmdir(File.join(remote_folder, local_folder)) if file_exists? File.join(remote_folder, local_folder)
+    def put_dir(opts = {})
+      # Set default options
+      options = {
+        :local     => ".",
+        :remote    => ".",
+        :verbose   => false,
+        :erase     => false,
+        :exclude   => []
+      }.merge!(opts)
       
-      Dir.chdir(local_folder)
-      chdir(remote_folder)
-
-      mkdir(File.basename(local_folder))
-      chdir(File.basename(local_folder))
-
-      Dir.foreach('.') do |f|      
-        if File.file?(f)
-          File.binary?(f) ? putbinaryfile(f) : puttextfile(f)
+      # Format options[:exclude]
+      unless options[:preformatted]
+        options[:exclude].map! { |f| File.join(options[:local], f) }
+        options[:preformatted] = true        
+      end
+      
+      # Check for existence of directory on remote server
+      # and create it if it isn't there. If it does exist,
+      # call sync_dir instead.
+      if !remote_file_exists?(options[:remote])
+        file_segments = options[:remote].split(File::SEPARATOR)
+        
+        # Make directory and all missing parent directories
+        file_segments.length.times do |n|
+          fpath = File.join(file_segments[0..n])
+          
+          unless remote_file_exists?(fpath) || fpath == ""
+            puts "mkdir #{fpath}" if options[:verbose] == true
+            mkdir(fpath)
+          end
+        end
+      else
+        options[:erase] ? (rmrf_dir(options[:remote], options[:verbose]); put_dir(options)) : sync_dir(options)
+        return
+      end
+      
+      # Upload files recursively
+      Dir.foreach(options[:local]) do |f|
+        local  = File.join(options[:local], f)
+        remote = File.join(options[:remote], f)
+        
+        (puts "excluding #{local}"; next) if options[:exclude].include?(local)
+        
+        if File.file?(local)
+          puts "cp #{remote}" if options[:verbose] == true
+          File.binary?(local) ? putbinaryfile(local, remote) : puttextfile(local, remote)
+          
+        # ignore . and .., but upload other directories
         elsif !f.match(/^\.+$/)
-          put_dir(File.path(f))
+          put_dir(options.merge({ :local => local, :remote => remote }))
         end
+        
       end
-
-      Dir.chdir('..')
-      chdir('..')
+      
     end
-
-    def sync_dir(local_folder, remote_folder = '.')
-      mkdir(remote_folder) if !file_exists?(remote_folder)
+    
+    def rmrf_dir(dir, verbose = false)
+      return if !remote_file_exists?(dir)
+      
+      # Get file list from the server and begin deleting files
+      begin
+        flist = nlst(dir)
+        
+        flist.each do |f|
+          # Ignore . and ..
+          next if f.match(/^\.+$/)
+          
+          # Try to delete the file. If we fail then it's a directory
+          begin
+            delete(f)
+            puts "rm #{f}" if verbose
+          rescue Exception => e
+            rmrf_dir(f, verbose)
+          end
+          
+        end
+      rescue Exception => e
+        # If the directory is empty, error silently and continue execution
+      end
       
-      Dir.chdir(local_folder)
-      chdir(remote_folder)
+      rmdir(dir)
+      puts "rm -rf #{dir}" if verbose
       
-      Dir.foreach('.') do |f|
-        if File.file?(f)
-          if !file_exists?(f) || mtime(f) < File.mtime(f)
-            File.binary?(f) ? putbinaryfile(f) : puttextfile(f)
+    end
+    
+    protected
+    
+    def sync_dir(options = {})
+      # Loop through each directory and compare/update the files
+      Dir.foreach(options[:local]) do |f|
+        local  = File.join(options[:local], f)
+        remote = File.join(options[:remote], f)
+        
+        (puts "excluding #{local}" if options[:verbose] == true; next) if options[:exclude].include?(local)
+        
+        if File.file?(local)
+          if !remote_file_exists?(remote) || mtime(remote) < File.mtime(local)
+            puts "updating #{remote}" if options[:verbose] == true
+            File.binary?(local) ? putbinaryfile(local, remote) : puttextfile(local, remote)
+            
+          else
+            puts "skipping #{remote}" if options[:verbose] == true
           end
         elsif !f.match(/^\.+$/)
-          mkdir(File.basename(f)) if !file_exists?(f)
-          sync_dir(File.path(f), f)
+          put_dir(options.merge(:local => local, :remote => remote))
         end
+      
       end
       
-      Dir.chdir('..')
-      chdir('..')
     end
     
-    protected
-    def file_exists?(file)
-      list = nlst
-      nlst.include?(file)
+    def remote_file_exists?(file)
+      fpath = file.split(File::SEPARATOR)
+
+      # If we're only one directory deep, don't try to join anything
+      if fpath.length == 1
+        # starting at file system root?
+        if file.match(/^#{File::SEPARATOR}/)
+          return nlst(File::SEPARATOR).include?(file)
+        # starting relative to FTP dir
+        else
+          return nlst.include?(file)
+        end
+      # Nested directories
+      else
+        fname = fpath.pop
+        fpath.map! { |v| v == "" ? File::SEPARATOR : v }
+        fpath = fpath.join(File::SEPARATOR)
+
+        # Wrap return in begin..rescue because nlst errors on empty directory
+        begin
+          return nlst(fpath).include?(File.join(fpath, fname))
+        rescue Exception => e
+          return false if e.message.match("450")
+        end
+
+      end
+
     end
     
   end

data/test/test_ftp-ext.rb

@@ -1,5 +1,19 @@
 require 'helper'
 
-class TestFtpExt < Test::Unit::TestCase
-  
-end
+class FTPExtTest < Test::Unit::TestCase
+  context "FTPExt should" do
+
+    setup do
+      @src = 'htdocs'
+    end
+
+    should "upload a directory to a linux machine" do
+      ftp = Net::FTP.new('localhost')
+      ftp.login('testuser', 'testpass')
+      
+      ftp.put_dir(@src)
+      puts ftp.nlst
+      assert true
+    end
+  end
+end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: ftp-ext
 version: !ruby/object:Gem::Version 
-  hash: 25
+  hash: 29
   prerelease: false
   segments: 
   - 0
   - 1
-  - 1
-  version: 0.1.1
+  - 3
+  version: 0.1.3
 platform: ruby
 authors: 
 - Zach Pendleton
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-10-12 00:00:00 -06:00
+date: 2010-12-30 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -50,7 +50,7 @@ dependencies:
         version: 1.1.9
   type: :runtime
   version_requirements: *id002
-description: ftp-ext adds two methods (sync_dir and put_dir) to Net::FTP to copy and sync whole folders over FTP.
+description: FTPExt adds two methods (put_dir and rmrf_dir) to Net::FTP to copy, sync, and delete whole folders over FTP.
 email: zachpendleton@gmail.com
 executables: []
 
@@ -58,12 +58,11 @@ extensions: []
 
 extra_rdoc_files: 
 - LICENSE
-- README.rdoc
 files: 
 - .document
 - .gitignore
 - LICENSE
-- README.rdoc
+- README.mdown
 - Rakefile
 - VERSION
 - ftp-ext.gemspec
@@ -103,7 +102,7 @@ rubyforge_project:
 rubygems_version: 1.3.7
 signing_key: 
 specification_version: 3
-summary: Folder copying methods for Net::FTP
+summary: Folder copying and deletion methods for Net::FTP
 test_files: 
 - test/helper.rb
 - test/test_ftp-ext.rb

data/README.rdoc

@@ -1,22 +0,0 @@
-= ftp-ext
-
-A simple gem for pushing and syncing entire folders over FTP. Adds two new
-public methods to Net::FTP -- put_dir and sync_dir. Both take two arguments:
-the local folder to be pushed, and the remote folder to be synced to. 
-
-Right now it's missing any error checking, but is useful for basic operations
-in controlled environments.
-
-== Note on Patches/Pull Requests
- 
-* Fork the project.
-* Make your feature addition or bug fix.
-* Add tests for it. This is important so I don't break it in a
-  future version unintentionally.
-* Commit, do not mess with rakefile, version, or history.
-  (if you want to have your own version, that is fine but bump version in a commit by itself I can ignore when I pull)
-* Send me a pull request. Bonus points for topic branches.
-
-== Copyright
-
-Copyright (c) 2010 Zach Pendleton. See LICENSE for details.