depengine 0.0.1

data/etc/isolate/ruby-1.8/gems/net-scp-1.0.2/test/common.rb

@@ -0,0 +1,138 @@
+require 'test/unit'
+require 'mocha'
+
+begin
+  gem 'net-ssh', ">= 2.0.0"
+  require 'net/ssh'
+rescue LoadError
+  $LOAD_PATH.unshift "#{File.dirname(__FILE__)}/../../net-ssh/lib"
+
+  begin
+    require 'net/ssh'
+    require 'net/ssh/version'
+    raise LoadError, "wrong version" unless Net::SSH::Version::STRING >= '1.99.0'
+  rescue LoadError => e
+    abort "could not load net/ssh v2 (#{e.inspect})"
+  end
+end
+
+$LOAD_PATH.unshift "#{File.dirname(__FILE__)}/../lib"
+
+require 'net/scp'
+require 'net/ssh/test'
+
+class Net::SSH::Test::Channel
+  def gets_ok
+    gets_data "\0"
+  end
+
+  def sends_ok
+    sends_data "\0"
+  end
+end
+
+class Net::SCP::TestCase < Test::Unit::TestCase
+  include Net::SSH::Test
+
+  def default_test
+    # do nothing, this is just a hacky-hack to work around Test::Unit's
+    # insistence that all TestCase subclasses have at least one test
+    # method defined.
+  end
+
+  protected
+
+    def prepare_file(path, contents="", mode=0666, mtime=Time.now, atime=Time.now)
+      entry = FileEntry.new(path, contents, mode, mtime, atime)
+      entry.stub!
+      entry
+    end
+
+    def prepare_directory(path, mode=0777, mtime=Time.now, atime=Time.now)
+      directory = DirectoryEntry.new(path, mode, mtime, atime)
+      yield directory if block_given?
+      directory.stub!
+    end
+
+    class FileEntry
+      attr_reader :path, :contents, :mode, :mtime, :atime, :io
+
+      def initialize(path, contents, mode=0666, mtime=Time.now, atime=Time.now)
+        @path, @contents, @mode = path, contents, mode
+        @mtime, @atime = mtime, atime
+      end
+
+      def name
+        @name ||= File.basename(path)
+      end
+
+      def stub!
+        stat = Mocha::Mock.new("file::stat")
+        stat.stubs(:size => contents.length, :mode => mode, :mtime => mtime, :atime => atime, :directory? => false)
+
+        File.stubs(:stat).with(path).returns(stat)
+        File.stubs(:directory?).with(path).returns(false)
+        File.stubs(:file?).with(path).returns(true)
+        File.stubs(:open).with(path, "rb").returns(StringIO.new(contents))
+
+        @io = StringIO.new
+        File.stubs(:new).with(path, "wb", mode).returns(io)
+      end
+    end
+
+    class DirectoryEntry
+      attr_reader :path, :mode, :mtime, :atime
+      attr_reader :entries
+
+      def initialize(path, mode=0777, mtime=Time.now, atime=Time.now)
+        @path, @mode = path, mode
+        @mtime, @atime = mtime, atime
+        @entries = []
+      end
+
+      def name
+        @name ||= File.basename(path)
+      end
+
+      def file(name, *args)
+        (entries << FileEntry.new(File.join(path, name), *args)).last
+      end
+
+      def directory(name, *args)
+        entry = DirectoryEntry.new(File.join(path, name), *args)
+        yield entry if block_given?
+        (entries << entry).last
+      end
+
+      def stub!
+        Dir.stubs(:mkdir).with { |*a| a.first == path }
+
+        stat = Mocha::Mock.new("file::stat")
+        stat.stubs(:size => 1024, :mode => mode, :mtime => mtime, :atime => atime, :directory? => true)
+
+        File.stubs(:stat).with(path).returns(stat)
+        File.stubs(:directory?).with(path).returns(true)
+        File.stubs(:file?).with(path).returns(false)
+        Dir.stubs(:entries).with(path).returns(%w(. ..) + entries.map { |e| e.name }.sort)
+
+        entries.each { |e| e.stub! }
+      end
+    end
+
+    def expect_scp_session(arguments)
+      story do |session|
+        channel = session.opens_channel
+        channel.sends_exec "scp #{arguments}"
+        yield channel if block_given?
+        channel.sends_eof
+        channel.gets_exit_status
+        channel.gets_eof
+        channel.gets_close
+        channel.sends_close
+      end
+    end
+
+    def scp(options={})
+      @scp ||= Net::SCP.new(connection(options))
+    end
+end

data/etc/isolate/ruby-1.8/gems/net-scp-1.0.2/test/test_all.rb

@@ -0,0 +1,3 @@
+Dir.chdir(File.dirname(__FILE__)) do
+  Dir['**/test_*.rb'].each { |file| require(file) }
+end

data/etc/isolate/ruby-1.8/gems/net-scp-1.0.2/test/test_download.rb

@@ -0,0 +1,156 @@
+require 'common'
+
+class TestDownload < Net::SCP::TestCase
+  def test_download_file_should_transfer_file
+    file = prepare_file("/path/to/local.txt", "a" * 1234)
+
+    expect_scp_session "-f /path/to/remote.txt" do |channel|
+      simple_download(channel)
+    end
+
+    assert_scripted { scp.download!("/path/to/remote.txt", "/path/to/local.txt") }
+    assert_equal "a" * 1234, file.io.string
+  end
+
+  def test_download_file_with_spaces_in_name_should_escape_remote_file_name
+    file = prepare_file("/path/to/local file.txt", "")
+
+    expect_scp_session "-f /path/to/remote\\ file.txt" do |channel|
+      channel.sends_ok
+      channel.gets_data "C0666 0 local file.txt\n"
+      channel.sends_ok
+      channel.gets_ok
+      channel.sends_ok
+    end
+
+    assert_scripted { scp.download!("/path/to/remote file.txt", "/path/to/local file.txt") }
+  end
+
+  def test_download_with_preserve_should_send_times
+    file = prepare_file("/path/to/local.txt", "a" * 1234, 0644, Time.at(1234567890, 123456), Time.at(12121212, 232323))
+
+    expect_scp_session "-f -p /path/to/remote.txt" do |channel|
+      channel.sends_ok
+      channel.gets_data "T1234567890 123456 12121212 232323\n"
+      simple_download(channel, 0644)
+    end
+
+    File.expects(:utime).with(Time.at(12121212, 232323), Time.at(1234567890, 123456), "/path/to/local.txt")
+    assert_scripted { scp.download!("/path/to/remote.txt", "/path/to/local.txt", :preserve => true) }
+    assert_equal "a" * 1234, file.io.string
+  end
+
+  def test_download_with_progress_callback_should_invoke_callback
+    prepare_file("/path/to/local.txt", "a" * 3000 + "b" * 3000 + "c" * 3000 + "d" * 3000)
+
+    expect_scp_session "-f /path/to/remote.txt" do |channel|
+      channel.sends_ok
+      channel.gets_data "C0666 12000 remote.txt\n"
+      channel.sends_ok
+      channel.gets_data "a" * 3000
+      channel.inject_remote_delay!
+      channel.gets_data "b" * 3000
+      channel.inject_remote_delay!
+      channel.gets_data "c" * 3000
+      channel.inject_remote_delay!
+      channel.gets_data "d" * 3000
+      channel.gets_ok
+      channel.sends_ok
+    end
+
+    calls = []
+    progress = Proc.new { |ch, *args| calls << args }
+
+    assert_scripted do
+      scp.download!("/path/to/remote.txt", "/path/to/local.txt", &progress)
+    end
+
+    assert_equal ["/path/to/local.txt",     0, 12000], calls.shift
+    assert_equal ["/path/to/local.txt",  3000, 12000], calls.shift
+    assert_equal ["/path/to/local.txt",  6000, 12000], calls.shift
+    assert_equal ["/path/to/local.txt",  9000, 12000], calls.shift
+    assert_equal ["/path/to/local.txt", 12000, 12000], calls.shift
+    assert calls.empty?
+  end
+
+  def test_download_io_with_recursive_should_raise_error
+    expect_scp_session "-f -r /path/to/remote.txt"
+    assert_raises(Net::SCP::Error) { scp.download!("/path/to/remote.txt", StringIO.new, :recursive => true) }
+  end
+
+  def test_download_io_with_preserve_should_ignore_preserve
+    expect_scp_session "-f -p /path/to/remote.txt" do |channel|
+      simple_download(channel)
+    end
+
+    io = StringIO.new
+    assert_scripted { scp.download!("/path/to/remote.txt", io, :preserve => true) }
+    assert_equal "a" * 1234, io.string
+  end
+
+  def test_download_io_should_transfer_data
+    expect_scp_session "-f /path/to/remote.txt" do |channel|
+      simple_download(channel)
+    end
+
+    io = StringIO.new
+    assert_scripted { scp.download!("/path/to/remote.txt", io) }
+    assert_equal "a" * 1234, io.string
+  end
+
+  def test_download_bang_without_target_should_return_string
+    expect_scp_session "-f /path/to/remote.txt" do |channel|
+      simple_download(channel)
+    end
+
+    assert_scripted do
+      assert_equal "a" * 1234, scp.download!("/path/to/remote.txt")
+    end
+  end
+
+  def test_download_directory_without_recursive_should_raise_error
+    expect_scp_session "-f /path/to/remote" do |channel|
+      channel.sends_ok
+      channel.gets_data "D0755 0 remote\n"
+    end
+
+    assert_raises(Net::SCP::Error) { scp.download!("/path/to/remote") }
+  end
+
+  def test_download_directory_should_create_directory_and_files_locally
+    file = nil
+    prepare_directory "/path/to/local" do |dir|
+      dir.directory "remote" do |dir2|
+        dir2.directory "sub" do |dir3|
+          file = dir3.file "remote.txt", ""
+        end
+      end
+    end
+
+    expect_scp_session "-f -r /path/to/remote" do |channel|
+      channel.sends_ok
+      channel.gets_data "D0755 0 remote\n"
+      channel.sends_ok
+      channel.gets_data "D0755 0 sub\n"
+      simple_download(channel)
+      channel.gets_data "E\n"
+      channel.sends_ok
+      channel.gets_data "E\n"
+      channel.sends_ok
+    end
+
+    scp.download!("/path/to/remote", "/path/to/local", :recursive => true, :ssh => { :verbose => :debug })
+    assert_equal "a" * 1234, file.io.string
+  end
+
+  private
+
+    def simple_download(channel, mode=0666)
+      channel.sends_ok
+      channel.gets_data "C%04o 1234 remote.txt\n" % mode
+      channel.sends_ok
+      channel.gets_data "a" * 1234
+      channel.gets_ok
+      channel.sends_ok
+    end
+end

data/etc/isolate/ruby-1.8/gems/net-scp-1.0.2/test/test_scp.rb

@@ -0,0 +1,60 @@
+require 'common'
+
+class TestSCP < Net::SCP::TestCase
+  def test_start_without_block_should_return_scp_instance
+    ssh = stub('session', :logger => nil)
+    Net::SSH.expects(:start).
+      with("remote.host", "username", :password => "foo").
+      returns(ssh)
+
+    ssh.expects(:close).never
+    scp = Net::SCP.start("remote.host", "username", :password => "foo")
+    assert_instance_of Net::SCP, scp
+    assert_equal ssh, scp.session
+  end
+
+  def test_start_with_block_should_yield_scp_and_close_ssh_session
+    ssh = stub('session', :logger => nil)
+    Net::SSH.expects(:start).
+      with("remote.host", "username", :password => "foo").
+      returns(ssh)
+
+    ssh.expects(:loop)
+    ssh.expects(:close)
+
+    yielded = false
+    Net::SCP.start("remote.host", "username", :password => "foo") do |scp|
+      yielded = true
+      assert_instance_of Net::SCP, scp
+      assert_equal ssh, scp.session
+    end
+
+    assert yielded
+  end
+
+  def test_self_upload_should_instatiate_scp_and_invoke_synchronous_upload
+    scp = stub('scp')
+    scp.expects(:upload!).with("/path/to/local", "/path/to/remote", :recursive => true)
+
+    Net::SCP.expects(:start).
+      with("remote.host", "username", :password => "foo").
+      yields(scp)
+
+    Net::SCP.upload!("remote.host", "username", "/path/to/local", "/path/to/remote",
+      :ssh => { :password => "foo" }, :recursive => true)
+  end
+
+  def test_self_download_should_instatiate_scp_and_invoke_synchronous_download
+    scp = stub('scp')
+    scp.expects(:download!).with("/path/to/remote", "/path/to/local", :recursive => true).returns(:result)
+
+    Net::SCP.expects(:start).
+      with("remote.host", "username", :password => "foo").
+      yields(scp)
+
+    result = Net::SCP.download!("remote.host", "username", "/path/to/remote", "/path/to/local",
+      :ssh => { :password => "foo" }, :recursive => true)
+
+    assert_equal :result, result
+  end
+end

data/etc/isolate/ruby-1.8/gems/net-scp-1.0.2/test/test_upload.rb

@@ -0,0 +1,255 @@
+require 'common'
+
+class TestUpload < Net::SCP::TestCase
+  def test_upload_file_should_transfer_file
+    prepare_file("/path/to/local.txt", "a" * 1234)
+
+    expect_scp_session "-t /path/to/remote.txt" do |channel|
+      channel.gets_ok
+      channel.sends_data "C0666 1234 local.txt\n"
+      channel.gets_ok
+      channel.sends_data "a" * 1234
+      channel.sends_ok
+      channel.gets_ok
+    end
+
+    assert_scripted { scp.upload!("/path/to/local.txt", "/path/to/remote.txt") }
+  end
+
+  def test_upload_file_with_spaces_in_name_should_escape_remote_file_name
+    prepare_file("/path/to/local file.txt", "")
+
+    expect_scp_session "-t /path/to/remote\\ file.txt" do |channel|
+      channel.gets_ok
+      channel.sends_data "C0666 0 local file.txt\n"
+      channel.gets_ok
+      channel.sends_ok
+      channel.gets_ok
+    end
+
+    assert_scripted { scp.upload!("/path/to/local file.txt", "/path/to/remote file.txt") }
+  end
+
+  def test_upload_file_with_preserve_should_send_times
+    prepare_file("/path/to/local.txt", "a" * 1234, 0666, Time.at(1234567890, 123456), Time.at(1234543210, 345678))
+
+    expect_scp_session "-t -p /path/to/remote.txt" do |channel|
+      channel.gets_ok
+      channel.sends_data "T1234567890 123456 1234543210 345678\n"
+      channel.gets_ok
+      channel.sends_data "C0666 1234 local.txt\n"
+      channel.gets_ok
+      channel.sends_data "a" * 1234
+      channel.sends_ok
+      channel.gets_ok
+    end
+
+    assert_scripted { scp.upload!("/path/to/local.txt", "/path/to/remote.txt", :preserve => true) }
+  end
+
+  def test_upload_file_with_progress_callback_should_invoke_callback
+    prepare_file("/path/to/local.txt", "a" * 3000 + "b" * 3000 + "c" * 3000 + "d" * 3000)
+
+    expect_scp_session "-t /path/to/remote.txt" do |channel|
+      channel.gets_ok
+      channel.sends_data "C0666 12000 local.txt\n"
+      channel.gets_ok
+      channel.sends_data "a" * 3000
+      channel.sends_data "b" * 3000
+      channel.sends_data "c" * 3000
+      channel.sends_data "d" * 3000
+      channel.sends_ok
+      channel.gets_ok
+    end
+
+    calls = []
+    progress = Proc.new do |ch, name, sent, total|
+      calls << [name, sent, total]
+    end
+
+    assert_scripted do
+      scp.upload!("/path/to/local.txt", "/path/to/remote.txt", :chunk_size => 3000, &progress)
+    end
+
+    assert_equal ["/path/to/local.txt",     0, 12000], calls.shift
+    assert_equal ["/path/to/local.txt",  3000, 12000], calls.shift
+    assert_equal ["/path/to/local.txt",  6000, 12000], calls.shift
+    assert_equal ["/path/to/local.txt",  9000, 12000], calls.shift
+    assert_equal ["/path/to/local.txt", 12000, 12000], calls.shift
+    assert calls.empty?
+  end
+
+  def test_upload_io_with_recursive_should_ignore_recursive
+    expect_scp_session "-t -r /path/to/remote.txt" do |channel|
+      channel.gets_ok
+      channel.sends_data "C0640 1234 remote.txt\n"
+      channel.gets_ok
+      channel.sends_data "a" * 1234
+      channel.sends_ok
+      channel.gets_ok
+    end
+
+    io = StringIO.new("a" * 1234)
+    assert_scripted { scp.upload!(io, "/path/to/remote.txt", :recursive => true) }
+  end
+
+  def test_upload_io_with_preserve_should_ignore_preserve
+    expect_scp_session "-t -p /path/to/remote.txt" do |channel|
+      channel.gets_ok
+      channel.sends_data "C0640 1234 remote.txt\n"
+      channel.gets_ok
+      channel.sends_data "a" * 1234
+      channel.sends_ok
+      channel.gets_ok
+    end
+
+    io = StringIO.new("a" * 1234)
+    assert_scripted { scp.upload!(io, "/path/to/remote.txt", :preserve  => true) }
+  end
+
+  def test_upload_io_should_transfer_data
+    expect_scp_session "-t /path/to/remote.txt" do |channel|
+      channel.gets_ok
+      channel.sends_data "C0640 1234 remote.txt\n"
+      channel.gets_ok
+      channel.sends_data "a" * 1234
+      channel.sends_ok
+      channel.gets_ok
+    end
+
+    io = StringIO.new("a" * 1234)
+    assert_scripted { scp.upload!(io, "/path/to/remote.txt") }
+  end
+
+  def test_upload_io_with_mode_should_honor_mode_as_permissions
+    expect_scp_session "-t /path/to/remote.txt" do |channel|
+      channel.gets_ok
+      channel.sends_data "C0666 1234 remote.txt\n"
+      channel.gets_ok
+      channel.sends_data "a" * 1234
+      channel.sends_ok
+      channel.gets_ok
+    end
+
+    io = StringIO.new("a" * 1234)
+    assert_scripted { scp.upload!(io, "/path/to/remote.txt", :mode => 0666) }
+  end
+
+  def test_upload_directory_without_recursive_should_error
+    prepare_directory("/path/to/local")
+
+    expect_scp_session("-t /path/to/remote") do |channel|
+      channel.gets_ok
+    end
+
+    assert_raises(Net::SCP::Error) { scp.upload!("/path/to/local", "/path/to/remote") }
+  end
+
+  def test_upload_empty_directory_should_create_directory_and_finish
+    prepare_directory("/path/to/local")
+
+    expect_scp_session("-t -r /path/to/remote") do |channel|
+      channel.gets_ok
+      channel.sends_data "D0777 0 local\n"
+      channel.gets_ok
+      channel.sends_data "E\n"
+      channel.gets_ok
+    end
+
+    assert_scripted { scp.upload!("/path/to/local", "/path/to/remote", :recursive => true) }
+  end
+
+  def test_upload_directory_should_recursively_create_and_upload_items
+    prepare_directory("/path/to/local") do |d|
+      d.file "hello.txt", "hello world\n"
+      d.directory "others" do |d2|
+        d2.file "data.dat", "abcdefghijklmnopqrstuvwxyz"
+      end
+      d.file "zoo.doc", "going to the zoo\n"
+    end
+
+    expect_scp_session("-t -r /path/to/remote") do |channel|
+      channel.gets_ok
+      channel.sends_data "D0777 0 local\n"
+      channel.gets_ok
+      channel.sends_data "C0666 12 hello.txt\n"
+      channel.gets_ok
+      channel.sends_data "hello world\n"
+      channel.sends_ok
+      channel.gets_ok
+      channel.sends_data "D0777 0 others\n"
+      channel.gets_ok
+      channel.sends_data "C0666 26 data.dat\n"
+      channel.gets_ok
+      channel.sends_data "abcdefghijklmnopqrstuvwxyz"
+      channel.sends_ok
+      channel.gets_ok
+      channel.sends_data "E\n"
+      channel.gets_ok
+      channel.sends_data "C0666 17 zoo.doc\n"
+      channel.gets_ok
+      channel.sends_data "going to the zoo\n"
+      channel.sends_ok
+      channel.gets_ok
+      channel.sends_data "E\n"
+      channel.gets_ok
+    end
+
+    assert_scripted { scp.upload!("/path/to/local", "/path/to/remote", :recursive => true) }
+  end
+
+  def test_upload_directory_with_preserve_should_send_times_for_all_items
+    prepare_directory("/path/to/local", 0755, Time.at(17171717, 191919), Time.at(18181818, 101010)) do |d|
+      d.file "hello.txt", "hello world\n", 0640, Time.at(12345, 67890), Time.at(234567, 890)
+      d.directory "others", 0770, Time.at(112233, 4455), Time.at(22334455, 667788) do |d2|
+        d2.file "data.dat", "abcdefghijklmnopqrstuvwxyz", 0600, Time.at(13579135, 13131), Time.at(7654321, 654321)
+      end
+      d.file "zoo.doc", "going to the zoo\n", 0444, Time.at(12121212, 131313), Time.at(23232323, 242424)
+    end
+
+    expect_scp_session("-t -r -p /path/to/remote") do |channel|
+      channel.gets_ok
+      channel.sends_data "T17171717 191919 18181818 101010\n"
+      channel.gets_ok
+      channel.sends_data "D0755 0 local\n"
+      channel.gets_ok
+      channel.sends_data "T12345 67890 234567 890\n"
+      channel.gets_ok
+      channel.sends_data "C0640 12 hello.txt\n"
+      channel.gets_ok
+      channel.sends_data "hello world\n"
+      channel.sends_ok
+      channel.gets_ok
+      channel.sends_data "T112233 4455 22334455 667788\n"
+      channel.gets_ok
+      channel.sends_data "D0770 0 others\n"
+      channel.gets_ok
+      channel.sends_data "T13579135 13131 7654321 654321\n"
+      channel.gets_ok
+      channel.sends_data "C0600 26 data.dat\n"
+      channel.gets_ok
+      channel.sends_data "abcdefghijklmnopqrstuvwxyz"
+      channel.sends_ok
+      channel.gets_ok
+      channel.sends_data "E\n"
+      channel.gets_ok
+      channel.sends_data "T12121212 131313 23232323 242424\n"
+      channel.gets_ok
+      channel.sends_data "C0444 17 zoo.doc\n"
+      channel.gets_ok
+      channel.sends_data "going to the zoo\n"
+      channel.sends_ok
+      channel.gets_ok
+      channel.sends_data "E\n"
+      channel.gets_ok
+    end
+
+    assert_scripted { scp.upload!("/path/to/local", "/path/to/remote", :preserve => true, :recursive => true) }
+  end
+
+  def test_upload_should_not_block
+    prepare_file("/path/to/local.txt", "data")
+    story { |s| s.opens_channel(false) }
+    assert_scripted { scp.upload("/path/to/local.txt", "/path/to/remote.txt") }
+  end
+end

data/etc/isolate/ruby-1.8/gems/net-sftp-2.0.4/CHANGELOG.rdoc

@@ -0,0 +1,43 @@
+=== 2.0.4 / 23 Nov 2009
+
+* Fixed frozen string issue in StatusException.message [appoxy]
+
+
+=== 2.0.3 / 17 Nov 2009
+
+* Reference the correct Exception class when rescuing errors [Scott Tadman]
+
+
+=== 2.0.2 / 1 Feb 2009
+
+* Avoid using 'ensure' in Net::SFTP.start since it causes unfriendly behavior when exceptions are raised [Jamis Buck]
+
+
+=== 2.0.1 / 29 May 2008
+
+* Open files in binary mode to appease Windows [Jamis Buck]
+
+
+=== 2.0.0 / 1 May 2008
+
+* Make Net::SSH::Connection::Session#sftp accept an argument determining whether or not to block while the SFTP subsystem initializes (defaults to true) [Jamis Buck]
+
+* Allow Session#connect to be useful even in the open/opening states by invoking or queuing the callback block [Jamis Buck]
+
+* Allow custom properties to be set on upload/download initiation via the :properties option [Jamis Buck]
+
+* Custom properties on Download instances [Jamis Buck]
+
+* Add #abort! method to Upload and Download operations [Jamis Buck]
+
+* More complete support for file-type detection in protocol versions 1-3 [Jamis Buck]
+
+
+=== 2.0 Preview Release 2 (1.99.1) / 10 Apr 2008
+
+* Custom properties on Upload instances [Jamis Buck]
+
+
+=== 2.0 Preview Release 1 (1.99.0) / 22 Mar 2008
+
+* Rewritten! (Never, ever, do this at home.) New and improved API.