ftputils 0.1.0

data/.document

@@ -0,0 +1,5 @@
+README.rdoc
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE

data/.gitignore

@@ -0,0 +1,21 @@
+## MAC OS
+.DS_Store
+
+## TEXTMATE
+*.tmproj
+tmtags
+
+## EMACS
+*~
+\#*
+.\#*
+
+## VIM
+*.swp
+
+## PROJECT::GENERAL
+coverage
+rdoc
+pkg
+
+## PROJECT::SPECIFIC

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Bruz Marzolf
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,17 @@
+= ftputils
+
+Description goes here.
+
+== 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 Bruz Marzolf. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,46 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "ftputils"
+    gem.summary = %Q{Like FileUtils for FTP}
+    gem.description = %Q{Implements a subset of the methods in FileUtils for FTP URIs, falling back on FileUtils when a path doesn't look like FTP}
+    gem.email = "bmarzolf@systemsbiology.org"
+    gem.homepage = "http://github.com/bmarzolf/ftputils"
+    gem.authors = ["Bruz Marzolf"]
+    gem.add_dependency "ftpfxp", ">= 0.0.4"
+    gem.add_development_dependency "rspec", ">= 1.2.9"
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
+end
+
+require 'spec/rake/spectask'
+Spec::Rake::SpecTask.new(:spec) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.spec_files = FileList['spec/**/*_spec.rb']
+end
+
+Spec::Rake::SpecTask.new(:rcov) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+task :spec => :check_dependencies
+
+task :default => :spec
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "ftputils #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/lib/ftputils/ext/class.rb

@@ -0,0 +1,48 @@
+class Class
+  def cattr_reader(*syms)
+    syms.flatten.each do |sym|
+      next if sym.is_a?(Hash)
+      class_eval(<<-EOS, __FILE__, __LINE__)
+        unless defined? @@#{sym}
+          @@#{sym} = nil
+        end
+
+        def self.#{sym}
+          @@#{sym}
+        end
+
+        def #{sym}
+          @@#{sym}
+        end
+      EOS
+    end
+  end
+
+  def cattr_writer(*syms)
+    options = syms.last.is_a?(Hash) ? syms.pop : {}
+    syms.flatten.each do |sym|
+      class_eval(<<-EOS, __FILE__, __LINE__)
+        unless defined? @@#{sym}
+          @@#{sym} = nil
+        end
+
+        def self.#{sym}=(obj)
+          @@#{sym} = obj
+        end
+
+        #{"
+        def #{sym}=(obj)
+          @@#{sym} = obj
+        end
+        " unless options[:instance_writer] == false }
+      EOS
+    end
+  end
+
+  def cattr_accessor(*syms)
+    cattr_reader(*syms)
+    cattr_writer(*syms)
+  end
+end
+
+

data/lib/ftputils/ftpconnection.rb

@@ -0,0 +1,50 @@
+class FTPUtils
+  class FTPConnection
+    cattr_accessor :connections
+
+    def self.connect(uri)
+      if uri.match(/^ftp:\/\/(.*?):(.*?)@(.*?)(\/.*)*$/)
+        username = $1
+        password = $2
+        host = $3
+
+        connection = self.establish_connection(host, username, password)
+
+        # need to reset to the top directory since connections are cached and
+        # could have been left elsewhere. this also provides a way to see if the 
+        # connection has expired and needs to be reloaded
+        begin
+          connection.chdir "/"
+        rescue Net::FTPTempError
+          connection = self.establish_connection(host, username, password, true)
+          retry
+        end
+
+        return connection
+      else
+        raise "Invalid FTP URL provided: #{uri}"
+      end
+    end
+
+    def self.clear_connection_cache
+      self.connections = Hash.new
+    end
+
+    private
+
+    def self.establish_connection(host, username, password, reload = false)
+      self.connections ||= Hash.new
+
+      return connections[host] if connections[host] && !reload
+
+      connection = Net::FTPFXP.new
+      connection.passive = true
+      connection.connect(host)
+      connection.login(username, password) if username && password
+
+      connections[host] = connection
+
+      return connection
+    end
+  end
+end

data/lib/ftputils/ftpfile.rb

@@ -0,0 +1,106 @@
+class FTPUtils
+  class FTPFile
+
+    def self.basename(path, suffix=nil)
+      if ftp_uri = FTPUtils::FTPURI.parse(path)
+        if suffix
+          return ftp_uri.filename.gsub!(/#{suffix}\Z/,'')
+        else
+          return ftp_uri.filename
+        end
+      else
+        if suffix
+          return File.basename(path, suffix)
+        else
+          return File.basename(path)
+        end
+      end
+    end
+
+    def self.directory?(path)
+      if ftp_uri = FTPUtils::FTPURI.parse(path)
+        begin
+          connection = FTPUtils::FTPConnection.connect(path)
+          connection.chdir(ftp_uri.path)
+          
+          return true
+        rescue Net::FTPPermError
+          return false
+        end
+      else
+        return File.directory? path
+      end
+    end
+
+    def self.dirname(path)
+      if ftp_uri = FTPUtils::FTPURI.parse(path)
+        return ftp_uri.dirname
+      else
+        return File.dirname(path)
+      end
+    end
+
+    def self.exists?(path)
+      if ftp_uri = FTPUtils::FTPURI.parse(path)
+        connection = FTPUtils::FTPConnection.connect(path)
+        connection.chdir ftp_uri.dirname
+        if connection.size(ftp_uri.filename) > 0
+          return true
+        else
+          return false
+        end
+      else
+        return File.exists?(path)
+      end
+    end
+
+    def self.expand_path(path)
+      if ftp_uri = FTPUtils::FTPURI.parse(path)
+        return path
+      else
+        return File.expand_path(path)
+      end
+    end
+
+    def self.file?(path)
+      if ftp_uri = FTPUtils::FTPURI.parse(path)
+        connection = FTPUtils::FTPConnection.connect(path)
+        connection.chdir(ftp_uri.dirname)
+
+        begin
+          connection.size(ftp_uri.filename)
+          return true
+        rescue Net::FTPPermError
+          return false
+        end
+      else
+        return File.file? path
+      end
+    end
+
+    def self.mtime(path)
+      if ftp_uri = FTPUtils::FTPURI.parse(path)
+        connection = FTPUtils::FTPConnection.connect(path)
+        connection.chdir(ftp_uri.dirname)
+
+        return connection.mtime(ftp_uri.filename)
+      else
+        return File.mtime path
+      end
+    end
+
+    def self.relative_path(path)
+      if ftp_uri = FTPUtils::FTPURI.parse(path)
+        return ftp_uri.path
+      else
+        return nil
+      end
+    end
+
+    private
+
+    def self.ftp_url?(str)
+      str.match(/^ftp:\/\//i) ? true : false
+    end
+  end
+end

data/lib/ftputils/ftpuri.rb

@@ -0,0 +1,25 @@
+class FTPUtils
+  class FTPURI
+    attr_accessor :dirname, :filename, :path
+
+    def self.parse(uri)
+      if uri.match(/^ftp:\/\/.*?:.*?@.*?(\/.*)*$/)
+        path = $1 || "/"
+        parts = path.split(/\//)
+        filename = parts[-1]
+        dirname = parts[0..-2].join("\/")
+        dirname = "/" if dirname.empty?
+
+        ftp_uri = FTPURI.new(dirname, filename, path)
+      else
+        return nil
+      end
+    end
+
+    def initialize(dirname, filename, path)
+      self.dirname = dirname
+      self.filename = filename
+      self.path = path
+    end
+  end
+end

data/lib/ftputils.rb

@@ -0,0 +1,152 @@
+begin
+  require 'ftpfxp'
+rescue LoadError
+  require 'rubygems'
+  require 'ftpfxp'
+end
+
+require 'fileutils'
+require 'open-uri'
+
+class FTPUtils
+  def self.cp(src, dest, options = {})
+    # handle all combinations of copying to/from FTP and local files
+    case [ftp_url?(src), ftp_url?(dest)]
+    when [true, true]
+      raise "src should be a filename, not a directory" if FTPFile.directory?(src)
+
+      dest_path = FTPFile.dirname(dest) + "/" + ( FTPFile.basename(dest) || FTPFile.basename(src) )
+      FTPConnection.connect(src).fxpto(FTPConnection.connect(dest), dest_path, FTPFile.relative_path(src))
+    when [true, false]
+      raise "src should be a filename, not a directory" if FTPFile.directory?(src)
+
+      filename = FTPFile.basename(src)
+
+      if File.directory? dest
+        dest += "/#{filename}"
+      end
+
+      connection = FTPConnection.connect(src)
+      connection.chdir FTPFile.dirname(src)
+      connection.getbinaryfile filename, dest, 1024
+    when [false, true]
+      raise "src should be a filename, not a directory" if File.directory? src
+
+      dest_path = FTPFile.relative_path(dest)
+
+      if FTPFile.directory?(dest)
+        dest_path += "/#{File.basename(src)}"
+      end
+
+      connection = FTPConnection.connect(dest)
+      connection.chdir FTPFile.dirname(dest)
+      connection.putbinaryfile src, dest_path, 1024
+    when [false, false]
+      FileUtils.cp src, dest, options
+    end
+  end
+
+  def self.rm(path)
+    if ftp_url?(path)
+      raise "Can't use FTPUtils.rm on directories. Instead use FTPUtils.rm_r" if FTPFile.directory?(path)
+
+      connection = FTPConnection.connect(path)
+      connection.chdir FTPFile.dirname(path)
+      connection.delete FTPFile.basename(path)
+    else
+      FileUtils.rm path
+    end
+  end
+
+  def self.mv(src, dest, options = {})
+    cp(src, dest, options)
+    rm(src)
+  end
+
+  def self.rm_r(path)
+    if ftp_url?(path)
+      if FTPFile.directory?(path) 
+        connection = FTPConnection.connect(path)
+        connection.chdir FTPFile.relative_path(path)
+
+        files = connection.nlst
+        files.each {|file| rm_r "#{path}/#{file}"}
+
+        connection.rmdir FTPFile.relative_path(path)
+      else
+        rm(path)
+      end
+    else
+      FileUtils.rm_r path
+    end
+  end
+
+  def self.mkdir_p(path)
+    if ftp_url?(path)
+      connection = FTPConnection.connect(path)
+
+      subdirs = FTPFile.relative_path(path).split(/\//)
+      subdirs.each do |subdir|
+        next if subdir == ""
+
+        connection.mkdir subdir
+        connection.chdir subdir
+      end
+    else
+      FileUtils.mkdir_p path
+    end
+  end
+
+  def self.cp_r(src, dest, options = {})
+    # handle all combinations of copying to/from FTP and local files
+    if ftp_url?(src)
+      if FTPFile.directory?(src) 
+        mkdir_p dest
+
+        connection = FTPConnection.connect(src)
+        files = connection.nlst
+        files.each {|file| cp_r "#{src}/#{file}", "#{dest}/#{file}", options}
+      else
+        cp(src, dest, options)
+      end
+    elsif ftp_url?(dest)
+      if FTPFile.directory?(dest) 
+        mkdir_p dest
+
+        files = Dir.entries(src)
+        files.each {|file| cp_r "#{src}/#{file}", "#{dest}/#{file}", options}
+      else
+        cp(src, dest, options)
+      end
+    else
+      FileUtils.cp_r src, dest
+    end
+  end
+
+  def self.ls(path)
+    if ftp_url?(path)
+      if FTPFile.directory?(path) 
+        connection = FTPConnection.connect(path)
+        connection.chdir FTPFile.relative_path(path)
+
+        return connection.nlst
+      else
+        nil
+      end
+    else
+      Dir.entries path
+    end
+  end
+
+  private
+
+  def self.ftp_url?(str)
+    str.match(/^ftp:\/\//i) ? true : false
+  end
+
+end
+
+require 'ftputils/ext/class'
+require 'ftputils/ftpconnection'
+require 'ftputils/ftpuri'
+require 'ftputils/ftpfile'

data/spec/ftpconnection_spec.rb

@@ -0,0 +1,56 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe FTPUtils::FTPConnection do
+  before(:each) do
+    FTPUtils::FTPConnection.clear_connection_cache
+  end
+
+  describe "initializing a new FTP connection" do
+    it "should raise an error if it doesn't look like an FTP connection" do
+      lambda do
+        FTPUtils::FTPConnection.connect("path/to/file.txt")
+      end.should raise_error("Invalid FTP URL provided: path/to/file.txt")
+    end
+
+    it "should establish a connection to a directory" do
+      mock_connection = mock(Net::FTPFXP)
+      Net::FTPFXP.should_receive(:new).and_return(mock_connection)
+      mock_connection.should_receive(:"passive=").with(true)
+      mock_connection.should_receive(:connect).with("myhost")
+      mock_connection.should_receive(:login).with("admin","test")
+      mock_connection.should_receive(:chdir).with("/")
+
+      FTPUtils::FTPConnection.connect("ftp://admin:test@myhost/path/to/directory")
+    end
+
+    it "should establish a connection to a host without a directory name" do
+      mock_connection = mock(Net::FTPFXP)
+      Net::FTPFXP.should_receive(:new).and_return(mock_connection)
+      mock_connection.should_receive(:"passive=").with(true)
+      mock_connection.should_receive(:connect).with("myhost")
+      mock_connection.should_receive(:login).with("admin","test")
+      mock_connection.should_receive(:chdir).with("/")
+
+      FTPUtils::FTPConnection.connect("ftp://admin:test@myhost")
+    end
+
+    it "should attempt to reconnect once if there is an error" do
+      mock_connection = mock(Net::FTPFXP)
+      Net::FTPFXP.should_receive(:new).and_return(mock_connection)
+      mock_connection.should_receive(:"passive=").with(true)
+      mock_connection.should_receive(:connect).with("myhost")
+      mock_connection.should_receive(:login).with("admin","test")
+      mock_connection.should_receive(:chdir).with("/").and_raise(Net::FTPTempError)
+      mock_connection_2 = mock(Net::FTPFXP)
+      Net::FTPFXP.should_receive(:new).and_return(mock_connection_2)
+      mock_connection_2.should_receive(:"passive=").with(true)
+      mock_connection_2.should_receive(:connect).with("myhost")
+      mock_connection_2.should_receive(:login).with("admin","test")
+      mock_connection_2.should_receive(:chdir).with("/").and_raise(Net::FTPPermError)
+
+      lambda do
+        FTPUtils::FTPConnection.connect("ftp://admin:test@myhost/path/to/file.txt")
+      end.should raise_error(Net::FTPPermError)
+    end
+  end
+end

data/spec/ftpfile_spec.rb

@@ -0,0 +1,177 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe FTPUtils::FTPURI do
+  describe "checking to see if a path is a directory" do
+    it "should be true when the path is an FTP directory" do
+      mock_uri = mock(FTPUtils::FTPURI, :path => "/path/to/directory")
+      FTPUtils::FTPURI.should_receive(:parse).with("ftp://admin:test@myhost/path/to/directory").and_return(mock_uri)
+      mock_connection = mock(FTPUtils::FTPConnection)
+      FTPUtils::FTPConnection.should_receive(:connect).with("ftp://admin:test@myhost/path/to/directory").and_return(mock_connection)
+      mock_connection.should_receive(:chdir).with("/path/to/directory")
+
+      FTPUtils::FTPFile.directory?("ftp://admin:test@myhost/path/to/directory").should be_true
+    end
+
+    it "should be false when the path is an FTP file" do
+      mock_uri = mock(FTPUtils::FTPURI, :path => "/path/to/file.txt")
+      FTPUtils::FTPURI.should_receive(:parse).with("ftp://admin:test@myhost/path/to/file.txt").and_return(mock_uri)
+      mock_connection = mock(FTPUtils::FTPConnection)
+      FTPUtils::FTPConnection.should_receive(:connect).with("ftp://admin:test@myhost/path/to/file.txt").and_return(mock_connection)
+      mock_connection.should_receive(:chdir).with("/path/to/file.txt").and_raise(Net::FTPPermError)
+
+      FTPUtils::FTPFile.directory?("ftp://admin:test@myhost/path/to/file.txt").should be_false
+    end
+
+    it "should check the path using File.directory? if it doesn't look like an FTP URI" do
+      FTPUtils::FTPURI.should_receive(:parse).with("/path/to/file.txt").and_return(nil)
+      File.should_receive(:directory?).with("/path/to/file.txt")
+
+      FTPUtils::FTPFile.directory?("/path/to/file.txt")
+    end
+  end
+
+  describe "providing the directory name of a path" do
+    it "should provide the directory name of an FTP URI" do
+      mock_uri = mock(FTPUtils::FTPURI, :dirname => "/path/to")
+      FTPUtils::FTPURI.should_receive(:parse).with("ftp://admin:test@myhost/path/to/file.txt").and_return(mock_uri)
+
+      FTPUtils::FTPFile.dirname("ftp://admin:test@myhost/path/to/file.txt").should == "/path/to"
+    end
+
+    it "should provide the directory name of a non-FTP path" do
+      FTPUtils::FTPURI.should_receive(:parse).with("/path/to/file.txt").and_return(nil)
+      File.should_receive(:dirname).with("/path/to/file.txt").and_return("/path/to")
+
+      FTPUtils::FTPFile.dirname("/path/to/file.txt").should == "/path/to"
+    end
+  end
+
+  describe "checking to see if a file exists" do
+    it "should be true when an FTP URI has size greater than 0" do
+      mock_uri = mock(FTPUtils::FTPURI, :path => "/path/to/file.txt", :dirname => "/path/to", :filename => "file.txt")
+      FTPUtils::FTPURI.should_receive(:parse).with("ftp://admin:test@myhost/path/to/file.txt").and_return(mock_uri)
+      mock_connection = mock(FTPUtils::FTPConnection)
+      FTPUtils::FTPConnection.should_receive(:connect).with("ftp://admin:test@myhost/path/to/file.txt").and_return(mock_connection)
+      mock_connection.should_receive(:chdir).with("/path/to")
+      mock_connection.should_receive(:size).with("file.txt").and_return(100)
+
+      FTPUtils::FTPFile.exists?("ftp://admin:test@myhost/path/to/file.txt").should be_true
+    end
+
+    it "should be false when an FTP URI has size less than 0" do
+      mock_uri = mock(FTPUtils::FTPURI, :path => "/path/to/file.txt", :dirname => "/path/to", :filename => "file.txt")
+      FTPUtils::FTPURI.should_receive(:parse).with("ftp://admin:test@myhost/path/to/file.txt").and_return(mock_uri)
+      mock_connection = mock(FTPUtils::FTPConnection)
+      FTPUtils::FTPConnection.should_receive(:connect).with("ftp://admin:test@myhost/path/to/file.txt").and_return(mock_connection)
+      mock_connection.should_receive(:chdir).with("/path/to")
+      mock_connection.should_receive(:size).with("file.txt").and_return(-1)
+
+      FTPUtils::FTPFile.exists?("ftp://admin:test@myhost/path/to/file.txt").should be_false
+    end
+
+    it "should pass the path to File.exists? if it's not an FTP URI" do
+      FTPUtils::FTPURI.should_receive(:parse).with("/path/to/file.txt").and_return(nil)
+      File.should_receive(:exists?)
+
+      FTPUtils::FTPFile.exists?("/path/to/file.txt")
+    end
+  end
+
+  describe "providing the basename" do
+    it "should provide the basename of an FTP URI" do
+      mock_uri = mock(FTPUtils::FTPURI, :filename => "file.txt")
+      FTPUtils::FTPURI.should_receive(:parse).with("ftp://admin:test@myhost/path/to/file.txt").and_return(mock_uri)
+
+      FTPUtils::FTPFile.basename("ftp://admin:test@myhost/path/to/file.txt").should == "file.txt"
+    end
+
+    it "should provide the basename of a non-FTP path" do
+      FTPUtils::FTPURI.should_receive(:parse).with("/path/to/file.txt").and_return(nil)
+      File.should_receive(:basename).with("/path/to/file.txt")
+
+      FTPUtils::FTPFile.basename("/path/to/file.txt")
+    end
+  end
+
+  describe "providing the relative path" do
+    it "should provide the relative path for an FTP URI" do
+      mock_uri = mock(FTPUtils::FTPURI, :path => "/path/to")
+      FTPUtils::FTPURI.should_receive(:parse).with("ftp://admin:test@myhost/path/to/file.txt").and_return(mock_uri)
+
+      FTPUtils::FTPFile.relative_path("ftp://admin:test@myhost/path/to/file.txt").should == "/path/to"
+    end
+
+    it "should provide the relative path for a non-FTP path" do
+      FTPUtils::FTPURI.should_receive(:parse).with("/path/to/file.txt").and_return(nil)
+
+      FTPUtils::FTPFile.relative_path("/path/to/file.txt").should be_nil
+    end
+  end
+
+  describe "determining whether a path is a file" do
+    it "should be true for an FTP URI of a file" do
+      mock_uri = mock(FTPUtils::FTPURI, :dirname => "/path/to", :filename => "file.txt")
+      FTPUtils::FTPURI.should_receive(:parse).with("ftp://admin:test@myhost/path/to/file.txt").and_return(mock_uri)
+      mock_connection = mock(FTPUtils::FTPConnection)
+      FTPUtils::FTPConnection.should_receive(:connect).with("ftp://admin:test@myhost/path/to/file.txt").and_return(mock_connection)
+      mock_connection.should_receive(:chdir).with("/path/to")
+      mock_connection.should_receive(:size).with("file.txt").and_return(100)
+
+      FTPUtils::FTPFile.file?("ftp://admin:test@myhost/path/to/file.txt").should be_true
+    end
+
+    it "should be false for an FTP URI of a directory" do
+      mock_uri = mock(FTPUtils::FTPURI, :dirname => "/path/to", :filename => "directory")
+      FTPUtils::FTPURI.should_receive(:parse).with("ftp://admin:test@myhost/path/to/directory").and_return(mock_uri)
+      mock_connection = mock(FTPUtils::FTPConnection)
+      FTPUtils::FTPConnection.should_receive(:connect).with("ftp://admin:test@myhost/path/to/directory").and_return(mock_connection)
+      mock_connection.should_receive(:chdir).with("/path/to")
+      mock_connection.should_receive(:size).with("directory").and_raise(Net::FTPPermError)
+
+      FTPUtils::FTPFile.file?("ftp://admin:test@myhost/path/to/directory").should be_false
+    end
+
+    it "should use File.directory? if the path doesn't look like an FTP URI" do
+      FTPUtils::FTPURI.should_receive(:parse).with("/path/to/file.txt").and_return(nil)
+      File.should_receive(:file?).with("/path/to/file.txt")
+
+      FTPUtils::FTPFile.file?("/path/to/file.txt")
+    end
+  end
+
+  describe "determining the modification time of a file" do
+    it "should find the modification of an FTP URI" do
+      mock_uri = mock(FTPUtils::FTPURI, :dirname => "/path/to", :filename => "file.txt")
+      FTPUtils::FTPURI.should_receive(:parse).with("ftp://admin:test@myhost/path/to/file.txt").and_return(mock_uri)
+      mock_connection = mock(FTPUtils::FTPConnection)
+      FTPUtils::FTPConnection.should_receive(:connect).with("ftp://admin:test@myhost/path/to/file.txt").and_return(mock_connection)
+      mock_connection.should_receive(:chdir).with("/path/to")
+      mock_connection.should_receive(:mtime).with("file.txt").and_return("10:10")
+
+      FTPUtils::FTPFile.mtime("ftp://admin:test@myhost/path/to/file.txt").should == "10:10"
+    end
+
+    it "should use File.mtime if the path is not an FTP URI" do
+      FTPUtils::FTPURI.should_receive(:parse).with("/path/to/file.txt").and_return(nil)
+      File.should_receive(:mtime).with("/path/to/file.txt")
+
+      FTPUtils::FTPFile.mtime("/path/to/file.txt")
+    end
+  end
+
+  describe "expanding the path" do
+    it "should do nothing to the path if it's an FTP URI" do
+      mock_uri = mock(FTPUtils::FTPURI, :dirname => "/path/to", :filename => "file.txt")
+      FTPUtils::FTPURI.should_receive(:parse).with("ftp://admin:test@myhost/path/to/file.txt").and_return(mock_uri)
+
+      FTPUtils::FTPFile.expand_path("ftp://admin:test@myhost/path/to/file.txt").should == "ftp://admin:test@myhost/path/to/file.txt"
+    end
+
+    it "should use File.expand_path if it's not an FTP URI" do
+      FTPUtils::FTPURI.should_receive(:parse).with("/path/to/file.txt").and_return(nil)
+      File.should_receive(:expand_path).with("/path/to/file.txt")
+
+      FTPUtils::FTPFile.expand_path("/path/to/file.txt")
+    end
+  end
+end

data/spec/ftpuri_spec.rb

@@ -0,0 +1,25 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe FTPUtils::FTPURI do
+  it "should create a new URI if a valid FTP directory is provided" do
+    uri = FTPUtils::FTPURI.parse("ftp://admin:test@myhost/path/to/directory")
+    uri.dirname.should == "/path/to"
+    uri.filename.should == "directory"
+    uri.path.should == "/path/to/directory"
+  end
+
+  it "should create a new URI if just the hostname is provided" do
+    uri = FTPUtils::FTPURI.parse("ftp://admin:test@myhost")
+    uri.dirname.should == "/"
+    uri.filename.should be_nil
+    uri.path.should == "/"
+  end
+
+  it "should create a new URI if a valid FTP file is provided" do
+    uri = FTPUtils::FTPURI.parse("ftp://admin:test@myhost/path/to/file.txt")
+    uri.dirname.should == "/path/to"
+    uri.filename.should == "file.txt"
+    uri.path.should == "/path/to/file.txt"
+  end
+    
+end

data/spec/ftputils_spec.rb

@@ -0,0 +1,387 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe "FTPUtils" do
+  describe "copying a file" do
+    describe "from FTP to FTP" do
+      it "should work if a file URIs are specified for the source and destination" do
+        FTPUtils::FTPFile.should_receive(:directory?).with("ftp://admin:test@host1/file1.txt").
+          and_return(false)
+        FTPUtils::FTPFile.should_receive(:dirname).with("ftp://admin:test@host2/file2.txt").
+          and_return("/")
+        FTPUtils::FTPFile.should_receive(:basename).with("ftp://admin:test@host2/file2.txt").
+          and_return("file2.txt")
+
+        mock_src_connection = mock(FTPUtils::FTPConnection)
+        FTPUtils::FTPConnection.should_receive(:connect).with("ftp://admin:test@host1/file1.txt").
+          and_return(mock_src_connection)
+        mock_dest_connection = mock(FTPUtils::FTPConnection)
+        FTPUtils::FTPConnection.should_receive(:connect).with("ftp://admin:test@host2/file2.txt").
+          and_return(mock_dest_connection)
+        FTPUtils::FTPFile.should_receive(:relative_path).with("ftp://admin:test@host1/file1.txt").
+          and_return("/file1.txt")
+        mock_src_connection.should_receive(:fxpto).with(mock_dest_connection, "//file2.txt", "/file1.txt")
+      
+        FTPUtils.cp "ftp://admin:test@host1/file1.txt", "ftp://admin:test@host2/file2.txt"
+      end
+
+      it "should work if a file URI with subdirnames are specified for the source and destination" do
+        FTPUtils::FTPFile.should_receive(:directory?).with("ftp://admin:test@host1/subdir1/file1.txt").
+          and_return(false)
+        FTPUtils::FTPFile.should_receive(:dirname).with("ftp://admin:test@host2/subdir2/file2.txt").
+          and_return("/subdir2")
+        FTPUtils::FTPFile.should_receive(:basename).with("ftp://admin:test@host2/subdir2/file2.txt").
+          and_return("file2.txt")
+
+        mock_src_connection = mock(FTPUtils::FTPConnection)
+        FTPUtils::FTPConnection.should_receive(:connect).with("ftp://admin:test@host1/subdir1/file1.txt").
+          and_return(mock_src_connection)
+        mock_dest_connection = mock(FTPUtils::FTPConnection)
+        FTPUtils::FTPConnection.should_receive(:connect).with("ftp://admin:test@host2/subdir2/file2.txt").
+          and_return(mock_dest_connection)
+        FTPUtils::FTPFile.should_receive(:relative_path).with("ftp://admin:test@host1/subdir1/file1.txt").
+          and_return("/subdir1/file1.txt")
+        mock_src_connection.should_receive(:fxpto).with(mock_dest_connection, "/subdir2/file2.txt", "/subdir1/file1.txt")
+      
+        FTPUtils.cp "ftp://admin:test@host1/subdir1/file1.txt", "ftp://admin:test@host2/subdir2/file2.txt"
+      end
+
+      it "should work if a file URI is specified for the source and a directory for the destination" do
+        FTPUtils::FTPFile.should_receive(:directory?).with("ftp://admin:test@host1/subdir1/file1.txt").
+          and_return(false)
+        FTPUtils::FTPFile.should_receive(:dirname).with("ftp://admin:test@host2/subdir2").
+          and_return("/subdir2")
+        FTPUtils::FTPFile.should_receive(:basename).with("ftp://admin:test@host2/subdir2").
+          and_return(nil)
+        FTPUtils::FTPFile.should_receive(:basename).with("ftp://admin:test@host1/subdir1/file1.txt").
+          and_return("file1.txt")
+
+        mock_src_connection = mock(FTPUtils::FTPConnection)
+        FTPUtils::FTPConnection.should_receive(:connect).with("ftp://admin:test@host1/subdir1/file1.txt").
+          and_return(mock_src_connection)
+        mock_dest_connection = mock(FTPUtils::FTPConnection)
+        FTPUtils::FTPConnection.should_receive(:connect).with("ftp://admin:test@host2/subdir2").
+          and_return(mock_dest_connection)
+        FTPUtils::FTPFile.should_receive(:relative_path).with("ftp://admin:test@host1/subdir1/file1.txt").
+          and_return("/subdir1/file1.txt")
+        mock_src_connection.should_receive(:fxpto).with(mock_dest_connection, "/subdir2/file1.txt", "/subdir1/file1.txt")
+      
+        FTPUtils.cp "ftp://admin:test@host1/subdir1/file1.txt", "ftp://admin:test@host2/subdir2"
+      end
+
+      it "should raise an error if the source URI is a directory" do
+        FTPUtils::FTPFile.should_receive(:directory?).with("ftp://admin:test@host1/subdir1").
+          and_return(true)
+      
+        lambda do
+          FTPUtils.cp "ftp://admin:test@host1/subdir1", "ftp://admin:test@host2/subdir2"
+        end.should raise_error("src should be a filename, not a directory")
+      end
+    end
+
+    describe "from FTP to the local filesystem" do
+      it "should work if the destination filename is given" do
+        FTPUtils::FTPFile.should_receive(:directory?).with("ftp://admin:test@host1/subdir1/file1.txt").
+          and_return(false)
+
+        FTPUtils::FTPFile.should_receive(:basename).with("ftp://admin:test@host1/subdir1/file1.txt").
+          and_return("file1.txt")
+
+        File.should_receive(:directory?).with("/home/me/file2.txt").and_return(false)
+
+        mock_src_connection = mock(FTPUtils::FTPConnection)
+        FTPUtils::FTPConnection.should_receive(:connect).with("ftp://admin:test@host1/subdir1/file1.txt").
+          and_return(mock_src_connection)
+        FTPUtils::FTPFile.should_receive(:dirname).with("ftp://admin:test@host1/subdir1/file1.txt").
+          and_return("/subdir1")
+        mock_src_connection.should_receive(:chdir).with("/subdir1")
+        mock_src_connection.should_receive(:getbinaryfile).with("file1.txt", "/home/me/file2.txt", 1024)
+
+        FTPUtils.cp "ftp://admin:test@host1/subdir1/file1.txt", "/home/me/file2.txt"
+      end
+
+      it "should work if the destination directory is given" do
+        FTPUtils::FTPFile.should_receive(:directory?).with("ftp://admin:test@host1/subdir1/file1.txt").
+          and_return(false)
+
+        FTPUtils::FTPFile.should_receive(:basename).with("ftp://admin:test@host1/subdir1/file1.txt").
+          and_return("file1.txt")
+
+        File.should_receive(:directory?).with("/home/me").and_return(true)
+
+        mock_src_connection = mock(FTPUtils::FTPConnection)
+        FTPUtils::FTPConnection.should_receive(:connect).with("ftp://admin:test@host1/subdir1/file1.txt").
+          and_return(mock_src_connection)
+        FTPUtils::FTPFile.should_receive(:dirname).with("ftp://admin:test@host1/subdir1/file1.txt").
+          and_return("/subdir1")
+        mock_src_connection.should_receive(:chdir).with("/subdir1")
+        mock_src_connection.should_receive(:getbinaryfile).with("file1.txt", "/home/me/file1.txt", 1024)
+
+        FTPUtils.cp "ftp://admin:test@host1/subdir1/file1.txt", "/home/me"
+      end
+
+      it "should raise an error if the source URI is a directory" do
+        FTPUtils::FTPFile.should_receive(:directory?).with("ftp://admin:test@host1/subdir1").
+          and_return(true)
+
+        lambda do
+          FTPUtils.cp "ftp://admin:test@host1/subdir1", "/home/me"
+        end.should raise_error("src should be a filename, not a directory")
+      end
+    end
+
+    describe "from local filesystem to FTP" do
+      it "should work if the source is a file and the destination is a file" do
+        File.should_receive(:directory?).with("/home/me/file1.txt").and_return(false)
+        FTPUtils::FTPFile.should_receive(:relative_path).with("ftp://admin:test@host2/file2.txt").
+          and_return("/file2.txt")
+        FTPUtils::FTPFile.should_receive(:directory?).with("ftp://admin:test@host2/file2.txt").
+          and_return(false)
+        mock_dest_connection = mock(FTPUtils::FTPConnection)
+        FTPUtils::FTPConnection.should_receive(:connect).with("ftp://admin:test@host2/file2.txt").
+          and_return(mock_dest_connection)
+        FTPUtils::FTPFile.should_receive(:dirname).with("ftp://admin:test@host2/file2.txt").and_return("/")
+        mock_dest_connection.should_receive(:chdir).with("/")
+        mock_dest_connection.should_receive(:putbinaryfile).with("/home/me/file1.txt", "/file2.txt", 1024)
+
+        FTPUtils.cp "/home/me/file1.txt", "ftp://admin:test@host2/file2.txt"
+      end
+
+      it "should work if the source is a file and the destination is a directory" do
+        File.should_receive(:directory?).with("/home/me/file1.txt").and_return(false)
+        FTPUtils::FTPFile.should_receive(:relative_path).with("ftp://admin:test@host2").
+          and_return("")
+        FTPUtils::FTPFile.should_receive(:directory?).with("ftp://admin:test@host2").
+          and_return(true)
+        File.should_receive(:basename).with("/home/me/file1.txt").and_return("file1.txt")
+        mock_dest_connection = mock(FTPUtils::FTPConnection)
+        FTPUtils::FTPConnection.should_receive(:connect).with("ftp://admin:test@host2").
+          and_return(mock_dest_connection)
+        FTPUtils::FTPFile.should_receive(:dirname).with("ftp://admin:test@host2").and_return("/")
+        mock_dest_connection.should_receive(:chdir).with("/")
+        mock_dest_connection.should_receive(:putbinaryfile).with("/home/me/file1.txt", "/file1.txt", 1024)
+
+        FTPUtils.cp "/home/me/file1.txt", "ftp://admin:test@host2"
+      end
+
+      it "should raise an error if the source file is a directory" do
+        File.should_receive(:directory?).with("/home/me").and_return(true)
+
+        lambda do
+          FTPUtils.cp "/home/me", "ftp://admin:test@host1/subdir1"
+        end.should raise_error("src should be a filename, not a directory")
+      end
+    end
+    
+    describe "from local filesystem to local filesystem" do
+      it "should fall back on FileUtils.cp" do
+        FileUtils.should_receive(:cp).with("file1.txt", "file2.txt", {})
+
+        FTPUtils.cp "file1.txt", "file2.txt"
+      end
+    end
+  end
+  
+  describe "removing a file" do
+    it "should remove an FTP directory" do
+      FTPUtils::FTPFile.should_receive(:directory?).with("ftp://admin:test@host1/subdir1/file.txt").
+        and_return(false)
+      mock_connection = mock(FTPUtils::FTPConnection)
+      FTPUtils::FTPConnection.should_receive(:connect).with("ftp://admin:test@host1/subdir1/file.txt").
+        and_return(mock_connection)
+      FTPUtils::FTPFile.should_receive(:dirname).with("ftp://admin:test@host1/subdir1/file.txt").and_return("/subdir1")
+      mock_connection.should_receive(:chdir).with("/subdir1")
+      mock_connection.should_receive(:delete).with("file.txt")
+
+      FTPUtils.rm "ftp://admin:test@host1/subdir1/file.txt"
+    end
+
+    it "should raise an error if an FTP directory is provided" do
+      FTPUtils::FTPFile.should_receive(:directory?).with("ftp://admin:test@host1/subdir1").
+        and_return(true)
+
+      lambda do
+        FTPUtils.rm "ftp://admin:test@host1/subdir1"
+      end.should raise_error("Can't use FTPUtils.rm on directories. Instead use FTPUtils.rm_r")
+    end
+
+    it "should fall back on FileUtils.rm if an FTP URI is not provided" do
+      FileUtils.should_receive(:rm).with("file.txt")
+
+      FTPUtils.rm "file.txt"
+    end
+  end
+
+  describe "removing recursively" do
+    it "should remove a directory with nested dirnames and files" do
+      FTPUtils::FTPFile.should_receive(:directory?).with("ftp://admin:test@host1/subdir1").
+        and_return(true)
+      mock_connection = mock(FTPUtils::FTPConnection)
+      FTPUtils::FTPConnection.should_receive(:connect).with("ftp://admin:test@host1/subdir1").
+        and_return(mock_connection)
+      mock_connection.should_receive(:chdir).with("/subdir1")
+      mock_connection.should_receive(:nlst).and_return( ["subdir2", "file.txt"] )
+
+      FTPUtils::FTPFile.should_receive(:directory?).with("ftp://admin:test@host1/subdir1/subdir2").
+        and_return(true)
+      mock_subdir_connection = mock(FTPUtils::FTPConnection)
+      FTPUtils::FTPConnection.should_receive(:connect).with("ftp://admin:test@host1/subdir1/subdir2").
+        and_return(mock_subdir_connection)
+      mock_subdir_connection.should_receive(:chdir).with("/subdir1/subdir2")
+      mock_subdir_connection.should_receive(:nlst).and_return( [] )
+      FTPUtils::FTPFile.should_receive(:relative_path).with("ftp://admin:test@host1/subdir1/subdir2").twice.
+        and_return("/subdir1/subdir2")
+      mock_subdir_connection.should_receive(:rmdir).with("/subdir1/subdir2")
+
+      FTPUtils::FTPFile.should_receive(:directory?).with("ftp://admin:test@host1/subdir1/file.txt").
+        and_return(false)
+      FTPUtils.should_receive(:rm).with("ftp://admin:test@host1/subdir1/file.txt")
+
+      FTPUtils::FTPFile.should_receive(:relative_path).with("ftp://admin:test@host1/subdir1").twice.
+        and_return("/subdir1")
+      mock_connection.should_receive(:rmdir).with("/subdir1")
+
+      FTPUtils.rm_r "ftp://admin:test@host1/subdir1"
+    end
+
+    it "should remove a file" do
+      FTPUtils::FTPFile.should_receive(:directory?).with("ftp://admin:test@host1/subdir1/file.txt").
+        and_return(false)
+      FTPUtils.should_receive(:rm).with("ftp://admin:test@host1/subdir1/file.txt")
+
+      FTPUtils.rm_r "ftp://admin:test@host1/subdir1/file.txt"
+    end
+
+    it "should fall back on FileUtils.rm_r if a non-FTP URI is provided" do
+      FileUtils.should_receive(:rm_r).with("dir")
+
+      FTPUtils.rm_r "dir"
+    end
+  end
+
+  describe "create a directory and all its parents" do
+    it "should work on an FTP URI" do
+      mock_connection = mock(FTPUtils::FTPConnection)
+      FTPUtils::FTPConnection.should_receive(:connect).with("ftp://admin:test@host1/subdir1/subdir2").
+        and_return(mock_connection)
+
+      FTPUtils::FTPFile.should_receive(:relative_path).with("ftp://admin:test@host1/subdir1/subdir2").
+        and_return("/subdir1/subdir2")
+
+      mock_connection.should_receive(:mkdir).with("subdir1")
+      mock_connection.should_receive(:chdir).with("subdir1")
+      mock_connection.should_receive(:mkdir).with("subdir2")
+      mock_connection.should_receive(:chdir).with("subdir2")
+
+      FTPUtils.mkdir_p "ftp://admin:test@host1/subdir1/subdir2"
+    end
+
+    it "should fall back on FileUtils for a non-FTP URI" do
+      FileUtils.should_receive(:mkdir_p).with("subdir1/subdir2")
+
+      FTPUtils.mkdir_p("subdir1/subdir2")
+    end
+  end
+
+  describe "copying recursively" do
+    it "should copy an FTP directory to another FTP directory" do
+      FTPUtils::FTPFile.should_receive(:directory?).with("ftp://admin:test@host1/subdir1").
+        and_return(true)
+      FTPUtils.should_receive(:mkdir_p).with("ftp://admin:test@host2/subdir2")
+      mock_src_connection = mock(FTPUtils::FTPConnection)
+      FTPUtils::FTPConnection.should_receive(:connect).with("ftp://admin:test@host1/subdir1").
+        and_return(mock_src_connection)
+      mock_src_connection.should_receive(:nlst).and_return( ["subdira", "file.txt"] )
+
+      FTPUtils::FTPFile.should_receive(:directory?).with("ftp://admin:test@host1/subdir1/subdira").
+        and_return(true)
+      FTPUtils.should_receive(:mkdir_p).with("ftp://admin:test@host2/subdir2/subdira")
+      mock_subdira_connection = mock(FTPUtils::FTPConnection)
+      FTPUtils::FTPConnection.should_receive(:connect).with("ftp://admin:test@host1/subdir1/subdira").
+        and_return(mock_subdira_connection)
+      mock_subdira_connection.should_receive(:nlst).and_return([])
+
+      FTPUtils::FTPFile.should_receive(:directory?).with("ftp://admin:test@host1/subdir1/file.txt").
+        and_return(false)
+      FTPUtils.should_receive(:cp).with("ftp://admin:test@host1/subdir1/file.txt",
+                                        "ftp://admin:test@host2/subdir2/file.txt", {})
+
+      FTPUtils.cp_r "ftp://admin:test@host1/subdir1", "ftp://admin:test@host2/subdir2"
+    end
+
+    it "should copy an FTP directory to a local directory" do
+      FTPUtils::FTPFile.should_receive(:directory?).with("ftp://admin:test@host1/subdir1").
+        and_return(true)
+      FTPUtils.should_receive(:mkdir_p).with("/home/me/subdir2")
+      mock_src_connection = mock(FTPUtils::FTPConnection)
+      FTPUtils::FTPConnection.should_receive(:connect).with("ftp://admin:test@host1/subdir1").
+        and_return(mock_src_connection)
+      mock_src_connection.should_receive(:nlst).and_return( ["subdira", "file.txt"] )
+
+      FTPUtils::FTPFile.should_receive(:directory?).with("ftp://admin:test@host1/subdir1/subdira").
+        and_return(true)
+      FTPUtils.should_receive(:mkdir_p).with("/home/me/subdir2/subdira")
+      mock_subdira_connection = mock(FTPUtils::FTPConnection)
+      FTPUtils::FTPConnection.should_receive(:connect).with("ftp://admin:test@host1/subdir1/subdira").
+        and_return(mock_subdira_connection)
+      mock_subdira_connection.should_receive(:nlst).and_return([])
+
+      FTPUtils::FTPFile.should_receive(:directory?).with("ftp://admin:test@host1/subdir1/file.txt").
+        and_return(false)
+      FTPUtils.should_receive(:cp).with("ftp://admin:test@host1/subdir1/file.txt",
+                                        "/home/me/subdir2/file.txt", {})
+
+      FTPUtils.cp_r "ftp://admin:test@host1/subdir1", "/home/me/subdir2"
+    end
+
+    it "should copy a local directory to an FTP directory" do
+      FTPUtils::FTPFile.should_receive(:directory?).with("ftp://admin:test@host2/subdir2").
+        and_return(true)
+      FTPUtils.should_receive(:mkdir_p).with("ftp://admin:test@host2/subdir2")
+      Dir.should_receive(:entries).with("/home/me/subdir1").and_return( ["subdira", "file.txt"] )
+
+      FTPUtils::FTPFile.should_receive(:directory?).with("ftp://admin:test@host2/subdir2/subdira").
+        and_return(true)
+      FTPUtils.should_receive(:mkdir_p).with("ftp://admin:test@host2/subdir2/subdira")
+      Dir.should_receive(:entries).with("/home/me/subdir1/subdira").and_return([])
+
+      FTPUtils::FTPFile.should_receive(:directory?).with("ftp://admin:test@host2/subdir2/file.txt").
+        and_return(false)
+      FTPUtils.should_receive(:cp).with("/home/me/subdir1/file.txt", "ftp://admin:test@host2/subdir2/file.txt", {})
+
+      FTPUtils.cp_r "/home/me/subdir1", "ftp://admin:test@host2/subdir2"
+    end
+
+    it "should copy a local directory to another local directory" do
+      FileUtils.should_receive(:cp_r).with("/home/me/subdir1", "/home/me/subdir2")
+
+      FTPUtils.cp_r "/home/me/subdir1", "/home/me/subdir2"
+    end
+  end
+
+  describe "listing the entries in a directory" do
+    it "should return a list of entries in an FTP directory" do
+      FTPUtils::FTPFile.should_receive(:directory?).with("ftp://admin:test@host1/subdir1").
+        and_return(true)
+      mock_connection = mock(FTPUtils::FTPConnection)
+      FTPUtils::FTPConnection.should_receive(:connect).with("ftp://admin:test@host1/subdir1").
+        and_return(mock_connection)
+      mock_connection.should_receive(:chdir).with("/subdir1")
+      mock_connection.should_receive(:nlst).and_return( ["subdir2", "file.txt"] )
+
+      FTPUtils.ls("ftp://admin:test@host1/subdir1").should == ["subdir2", "file.txt"]
+    end
+
+    it "should return nil for an FTP URI that isn't a directory" do
+      FTPUtils::FTPFile.should_receive(:directory?).with("ftp://admin:test@host1/file.txt").
+        and_return(false)
+
+      FTPUtils.ls("ftp://admin:test@host1/file.txt").should == nil
+    end
+
+    it "should use Dir.entries for a non-FTP URI" do
+      Dir.should_receive(:entries).with("/home/me/subdir1")
+
+      FTPUtils.ls("/home/me/subdir1")
+    end
+  end
+end

data/spec/spec.opts

@@ -0,0 +1 @@
+--color

data/spec/spec_helper.rb

@@ -0,0 +1,9 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'ftputils'
+require 'spec'
+require 'spec/autorun'
+
+Spec::Runner.configure do |config|
+  
+end

metadata

@@ -0,0 +1,110 @@
+--- !ruby/object:Gem::Specification 
+name: ftputils
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Bruz Marzolf
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-05-25 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: ftpfxp
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 0
+        - 4
+        version: 0.0.4
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 1
+        - 2
+        - 9
+        version: 1.2.9
+  type: :development
+  version_requirements: *id002
+description: Implements a subset of the methods in FileUtils for FTP URIs, falling back on FileUtils when a path doesn't look like FTP
+email: bmarzolf@systemsbiology.org
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.rdoc
+files: 
+- .document
+- .gitignore
+- LICENSE
+- README.rdoc
+- Rakefile
+- VERSION
+- lib/ftputils.rb
+- lib/ftputils/ext/class.rb
+- lib/ftputils/ftpconnection.rb
+- lib/ftputils/ftpfile.rb
+- lib/ftputils/ftpuri.rb
+- spec/ftpconnection_spec.rb
+- spec/ftpfile_spec.rb
+- spec/ftpuri_spec.rb
+- spec/ftputils_spec.rb
+- spec/spec.opts
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: http://github.com/bmarzolf/ftputils
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: Like FileUtils for FTP
+test_files: 
+- spec/ftpconnection_spec.rb
+- spec/ftpfile_spec.rb
+- spec/ftpuri_spec.rb
+- spec/ftputils_spec.rb
+- spec/spec_helper.rb