redcar 0.3.8.3 → 0.3.8.4

data/plugins/project/vendor/net-sftp/Rakefile

@@ -1,30 +0,0 @@
-$LOAD_PATH.unshift "../net-ssh/lib"
-require './lib/net/sftp/version'
-
-begin
-  require 'echoe'
-rescue LoadError
-  abort "You'll need to have `echoe' installed to use Net::SFTP's Rakefile"
-end
-
-version = Net::SFTP::Version::STRING.dup
-if ENV['SNAPSHOT'].to_i == 1
-  version << "." << Time.now.utc.strftime("%Y%m%d%H%M%S")
-end
-
-Echoe.new('net-sftp', version) do |p|
-  p.project          = "net-ssh"
-  p.changelog        = "CHANGELOG.rdoc"
-
-  p.author           = "Jamis Buck"
-  p.email            = "jamis@jamisbuck.org"
-  p.summary          = "A pure Ruby implementation of the SFTP client protocol"
-  p.url              = "http://net-ssh.rubyforge.org/sftp"
-
-  p.dependencies     = ["net-ssh >=2.0.9"]
-
-  p.need_zip         = true
-  p.include_rakefile = true
-
-  p.rdoc_pattern     = /^(lib|README.rdoc|CHANGELOG.rdoc)/
-end

data/plugins/project/vendor/net-sftp/lib/net/sftp.rb

@@ -1,70 +0,0 @@
-require 'net/ssh'
-require 'net/sftp/session'
-
-module Net
-
-  # Net::SFTP is a pure-Ruby module for programmatically interacting with a
-  # remote host via the SFTP protocol (that's SFTP as in "Secure File Transfer
-  # Protocol" produced by the Secure Shell Working Group, not "Secure FTP"
-  # and certainly not "Simple FTP").
-  #
-  # See Net::SFTP#start for an introduction to the library. Also, see
-  # Net::SFTP::Session for further documentation.
-  module SFTP
-    # A convenience method for starting a standalone SFTP session. It will
-    # start up an SSH session using the given arguments (see the documentation
-    # for Net::SSH::Session for details), and will then start a new SFTP session
-    # with the SSH session. This will block until the new SFTP is fully open
-    # and initialized before returning it.
-    #
-    #   sftp = Net::SFTP.start("localhost", "user")
-    #   sftp.upload! "/local/file.tgz", "/remote/file.tgz"
-    #
-    # If a block is given, it will be passed to the SFTP session and will be
-    # called once the SFTP session is fully open and initialized. When the
-    # block terminates, the new SSH session will automatically be closed.
-    #
-    #   Net::SFTP.start("localhost", "user") do |sftp|
-    #     sftp.upload! "/local/file.tgz", "/remote/file.tgz"
-    #   end
-    def self.start(host, user, options={}, &block)
-      session = Net::SSH.start(host, user, options)
-      sftp = Net::SFTP::Session.new(session, &block).connect!
-
-      if block_given?
-        sftp.loop
-        session.close
-        return nil
-      end
-
-      sftp
-    rescue Object => anything
-      begin
-        session.shutdown!
-      rescue ::Exception
-        # swallow exceptions that occur while trying to shutdown
-      end
-
-      raise anything
-    end
-  end
-
-end
-
-class Net::SSH::Connection::Session
-  # A convenience method for starting up a new SFTP connection on the current
-  # SSH session. Blocks until the SFTP session is fully open, and then
-  # returns the SFTP session.
-  #
-  #   Net::SSH.start("localhost", "user", "password") do |ssh|
-  #     ssh.sftp.upload!("/local/file.tgz", "/remote/file.tgz")
-  #     ssh.exec! "cd /some/path && tar xf /remote/file.tgz && rm /remote/file.tgz"
-  #   end
-  def sftp(wait=true)
-    @sftp ||= begin
-      sftp = Net::SFTP::Session.new(self)
-      sftp.connect! if wait
-      sftp
-    end
-  end
-end

data/plugins/project/vendor/net-sftp/lib/net/sftp/constants.rb

@@ -1,187 +0,0 @@
-module Net module SFTP
-
-  # The packet types and other general constants used by the SFTP protocol.
-  # See the specification for the SFTP protocol for a full discussion of their
-  # meaning and usage.
-  module Constants
-
-    # The various packet types supported by SFTP protocol versions 1 through 6.
-    # The FXP_EXTENDED and FXP_EXTENDED_REPLY packet types are not currently
-    # understood by Net::SFTP.
-    module PacketTypes
-      FXP_INIT           = 1
-      FXP_VERSION        = 2
-                         
-      FXP_OPEN           = 3
-      FXP_CLOSE          = 4
-      FXP_READ           = 5
-      FXP_WRITE          = 6
-      FXP_LSTAT          = 7
-      FXP_FSTAT          = 8
-      FXP_SETSTAT        = 9
-      FXP_FSETSTAT       = 10
-      FXP_OPENDIR        = 11
-      FXP_READDIR        = 12
-      FXP_REMOVE         = 13
-      FXP_MKDIR          = 14
-      FXP_RMDIR          = 15
-      FXP_REALPATH       = 16
-      FXP_STAT           = 17
-      FXP_RENAME         = 18
-      FXP_READLINK       = 19
-      FXP_SYMLINK        = 20
-      FXP_LINK           = 21
-      FXP_BLOCK          = 22
-      FXP_UNBLOCK        = 23
-                         
-      FXP_STATUS         = 101
-      FXP_HANDLE         = 102
-      FXP_DATA           = 103
-      FXP_NAME           = 104
-      FXP_ATTRS          = 105
-                         
-      FXP_EXTENDED       = 200
-      FXP_EXTENDED_REPLY = 201
-    end
-
-    # Beginning in version 5 of the protocol, Net::SFTP::Session#rename accepts
-    # an optional +flags+ argument that must be either 0 or a combination of
-    # these constants.
-    module RenameFlags
-      OVERWRITE = 0x00000001
-      ATOMIC    = 0x00000002
-      NATIVE    = 0x00000004
-    end
-
-    # When an FXP_STATUS packet is received from the server, the +code+ will
-    # be one of the following constants.
-    module StatusCodes
-      FX_OK                     = 0
-      FX_EOF                    = 1
-      FX_NO_SUCH_FILE           = 2
-      FX_PERMISSION_DENIED      = 3
-      FX_FAILURE                = 4
-      FX_BAD_MESSAGE            = 5
-      FX_NO_CONNECTION          = 6
-      FX_CONNECTION_LOST        = 7
-      FX_OP_UNSUPPORTED         = 8
-      FX_INVALID_HANDLE         = 9
-      FX_NO_SUCH_PATH           = 10
-      FX_FILE_ALREADY_EXISTS    = 11
-      FX_WRITE_PROTECT          = 12
-      FX_NO_MEDIA               = 13
-      FX_NO_SPACE_ON_FILESYSTEM = 14
-      FX_QUOTA_EXCEEDED         = 15
-      FX_UNKNOWN_PRINCIPLE      = 16
-      FX_LOCK_CONFlICT          = 17
-      FX_DIR_NOT_EMPTY          = 18
-      FX_NOT_A_DIRECTORY        = 19
-      FX_INVALID_FILENAME       = 20
-      FX_LINK_LOOP              = 21
-    end
-
-    # The Net::SFTP::Session#open operation is one of the worst casualties of
-    # the revisions between SFTP protocol versions. The flags change considerably
-    # between version 1 and version 6. Net::SFTP tries to shield programmers
-    # from the differences, so you'll almost never need to use these flags
-    # directly, but if you ever need to specify some flag that isn't exposed
-    # by the higher-level API, these are the ones that are available to you.
-    module OpenFlags
-      # These are the flags that are understood by versions 1-4 of the the
-      # open operation.
-      module FV1
-        READ   = 0x00000001
-        WRITE  = 0x00000002
-        APPEND = 0x00000004
-        CREAT  = 0x00000008
-        TRUNC  = 0x00000010
-        EXCL   = 0x00000020
-      end
-
-      # Version 5 of the open operation totally discarded the flags understood
-      # by versions 1-4, and replaced them with these.
-      module FV5
-        CREATE_NEW         = 0x00000000
-        CREATE_TRUNCATE    = 0x00000001
-        OPEN_EXISTING      = 0x00000002
-        OPEN_OR_CREATE     = 0x00000003
-        TRUNCATE_EXISTING  = 0x00000004
-
-        APPEND_DATA        = 0x00000008
-        APPEND_DATA_ATOMIC = 0x00000010
-        TEXT_MODE          = 0x00000020
-        READ_LOCK          = 0x00000040
-        WRITE_LOCK         = 0x00000080
-        DELETE_LOCK        = 0x00000100
-      end
-
-      # Version 6 of the open operation added these flags, in addition to the
-      # flags understood by version 5.
-      module FV6
-        ADVISORY_LOCK           = 0x00000200
-        NOFOLLOW                = 0x00000400
-        DELETE_ON_CLOSE         = 0x00000800
-        ACCESS_AUDIT_ALARM_INFO = 0x00001000
-        ACCESS_BACKUP           = 0x00002000
-        BACKUP_STREAM           = 0x00004000
-        OVERRIDE_OWNER          = 0x00008000
-      end
-    end
-
-    # The Net::SFTP::Session#block operation, implemented in version 6 of
-    # the protocol, understands these constants for the +mask+ parameter.
-    module LockTypes
-      READ     = OpenFlags::FV5::READ_LOCK
-      WRITE    = OpenFlags::FV5::WRITE_LOCK
-      DELETE   = OpenFlags::FV5::DELETE_LOCK
-      ADVISORY = OpenFlags::FV6::ADVISORY_LOCK
-    end
-
-    module ACE
-      # Access control entry types, used from version 4 of the protocol,
-      # onward. See Net::SFTP::Protocol::V04::Attributes::ACL.
-      module Type
-        ACCESS_ALLOWED = 0x00000000
-        ACCESS_DENIED  = 0x00000001
-        SYSTEM_AUDIT   = 0x00000002
-        SYSTEM_ALARM   = 0x00000003
-      end
-
-      # Access control entry flags, used from version 4 of the protocol,
-      # onward. See Net::SFTP::Protocol::V04::Attributes::ACL.
-      module Flag
-        FILE_INHERIT         = 0x00000001
-        DIRECTORY_INHERIT    = 0x00000002
-        NO_PROPAGATE_INHERIT = 0x00000004
-        INHERIT_ONLY         = 0x00000008
-        SUCCESSFUL_ACCESS    = 0x00000010
-        FAILED_ACCESS        = 0x00000020
-        IDENTIFIER_GROUP     = 0x00000040
-      end
-
-      # Access control entry masks, used from version 4 of the protocol,
-      # onward. See Net::SFTP::Protocol::V04::Attributes::ACL.
-      module Mask
-        READ_DATA         = 0x00000001
-        LIST_DIRECTORY    = 0x00000001
-        WRITE_DATA        = 0x00000002
-        ADD_FILE          = 0x00000002
-        APPEND_DATA       = 0x00000004
-        ADD_SUBDIRECTORY  = 0x00000004
-        READ_NAMED_ATTRS  = 0x00000008
-        WRITE_NAMED_ATTRS = 0x00000010
-        EXECUTE           = 0x00000020
-        DELETE_CHILD      = 0x00000040
-        READ_ATTRIBUTES   = 0x00000080
-        WRITE_ATTRIBUTES  = 0x00000100
-        DELETE            = 0x00010000
-        READ_ACL          = 0x00020000
-        WRITE_ACL         = 0x00040000
-        WRITE_OWNER       = 0x00080000
-        SYNCHRONIZE       = 0x00100000
-      end
-    end
-
-  end
-
-end end

data/plugins/project/vendor/net-sftp/lib/net/sftp/errors.rb

@@ -1,39 +0,0 @@
-module Net; module SFTP
-
-  # The base exception class for the SFTP system.
-  class Exception < RuntimeError; end
-
-  # A exception class for reporting a non-success result of an operation.
-  class StatusException < Net::SFTP::Exception
-
-    # The response object that caused the exception.
-    attr_reader :response
-
-    # The error code (numeric)
-    attr_reader :code
-
-    # The description of the error
-    attr_reader :description
-
-    # Any incident-specific text given when the exception was raised
-    attr_reader :text
-
-    # Create a new status exception that reports the given code and
-    # description.
-    def initialize(response, text=nil)
-      @response, @text = response, text
-      @code = response.code
-      @description = response.message
-      @description = Response::MAP[@code] if @description.nil? || @description.empty?
-    end
-
-    # Override the default message format, to include the code and
-    # description.
-    def message
-      m = super.dup
-      m << " #{text}" if text
-      m << " (#{code}, #{description.inspect})"
-    end
-
-  end
-end; end

data/plugins/project/vendor/net-sftp/lib/net/sftp/operations/dir.rb

@@ -1,93 +0,0 @@
-require 'net/ssh/loggable'
-
-module Net; module SFTP; module Operations
-
-  # A convenience class for working with remote directories. It provides methods
-  # for searching and enumerating directory entries, similarly to the standard
-  # ::Dir class.
-  #
-  #   sftp.dir.foreach("/remote/path") do |entry|
-  #     puts entry.name
-  #   end
-  #
-  #   p sftp.dir.entries("/remote/path").map { |e| e.name }
-  #
-  #   sftp.dir.glob("/remote/path", "**/*.rb") do |entry|
-  #     puts entry.name
-  #   end
-  class Dir
-    # The SFTP session object that drives this directory factory.
-    attr_reader :sftp
-
-    # Create a new instance on top of the given SFTP session instance.
-    def initialize(sftp)
-      @sftp = sftp
-    end
-
-    # Calls the block once for each entry in the named directory on the
-    # remote server. Yields a Name object to the block, rather than merely
-    # the name of the entry.
-    def foreach(path)
-      handle = sftp.opendir!(path)
-      while entries = sftp.readdir!(handle)
-        entries.each { |entry| yield entry }
-      end
-      return nil
-    ensure
-      sftp.close!(handle) if handle
-    end
-
-    # Returns an array of Name objects representing the items in the given
-    # remote directory, +path+.
-    def entries(path)
-      results = []
-      foreach(path) { |entry| results << entry }
-      return results
-    end
-
-    # Works as ::Dir.glob, matching (possibly recursively) all directory
-    # entries under +path+ against +pattern+. If a block is given, matches
-    # will be yielded to the block as they are found; otherwise, they will
-    # be returned in an array when the method finishes.
-    #
-    # Because working over an SFTP connection is always going to be slower than
-    # working purely locally, don't expect this method to perform with the
-    # same level of alacrity that ::Dir.glob does; it will work best for
-    # shallow directory hierarchies with relatively few directories, though
-    # it should be able to handle modest numbers of files in each directory.
-    def glob(path, pattern, flags=0)
-      flags |= ::File::FNM_PATHNAME
-      path = path.chop if path[-1,1] == "/"
-
-      results = [] unless block_given?
-      queue = entries(path).reject { |e| e.name == "." || e.name == ".." }
-      while queue.any?
-        entry = queue.shift
-
-        if entry.directory? && !%w(. ..).include?(::File.basename(entry.name))
-          queue += entries("#{path}/#{entry.name}").map do |e|
-            e.name.replace("#{entry.name}/#{e.name}")
-            e
-          end
-        end
-
-        if ::File.fnmatch(pattern, entry.name, flags)
-          if block_given?
-            yield entry
-          else
-            results << entry
-          end
-        end
-      end
-
-      return results unless block_given?
-    end
-
-    # Identical to calling #glob with a +flags+ parameter of 0 and no block.
-    # Simply returns the matched entries as an array.
-    def [](path, pattern)
-      glob(path, pattern, 0)
-    end
-  end
-
-end; end; end

data/plugins/project/vendor/net-sftp/lib/net/sftp/operations/download.rb

@@ -1,364 +0,0 @@
-require 'net/ssh/loggable'
-
-module Net; module SFTP; module Operations
-
-  # A general purpose downloader module for Net::SFTP. It can download files
-  # into IO objects, or directly to files on the local file system. It can
-  # even download entire directory trees via SFTP, and provides a flexible
-  # progress reporting mechanism.
-  #
-  # To download a single file from the remote server, simply specify both the
-  # remote and local paths:
-  #
-  #   downloader = sftp.download("/path/to/remote.txt", "/path/to/local.txt")
-  #
-  # By default, this operates asynchronously, so if you want to block until
-  # the download finishes, you can use the 'bang' variant:
-  #
-  #   sftp.download!("/path/to/remote.txt", "/path/to/local.txt")
-  #
-  # Or, if you have multiple downloads that you want to run in parallel, you can
-  # employ the #wait method of the returned object:
-  #
-  #   dls = %w(file1 file2 file3).map { |f| sftp.download("remote/#{f}", f) }
-  #   dls.each { |d| d.wait }
-  #
-  # To download an entire directory tree, recursively, simply specify :recursive => true:
-  #
-  #   sftp.download!("/path/to/remotedir", "/path/to/local", :recursive => true)
-  #
-  # This will download "/path/to/remotedir", it's contents, it's subdirectories,
-  # and their contents, recursively, to "/path/to/local" on the local host.
-  # (If you specify :recursive => true and the source is not a directory,
-  # you'll get an error!)
-  #
-  # If you want to pull the contents of a file on the remote server, and store
-  # the data in memory rather than immediately to disk, you can pass an IO
-  # object as the destination:
-  #
-  #   require 'stringio'
-  #   io = StringIO.new
-  #   sftp.download!("/path/to/remote", io)
-  #
-  # This will only work for single-file downloads. Trying to do so with
-  # :recursive => true will cause an error.
-  #
-  # The following options are supported:
-  #
-  # * <tt>:progress</tt> - either a block or an object to act as a progress
-  #   callback. See the discussion of "progress monitoring" below.
-  # * <tt>:requests</tt> - the number of pending SFTP requests to allow at
-  #   any given time. When downloading an entire directory tree recursively,
-  #   this will default to 16. Setting this higher might improve throughput.
-  #   Reducing it will reduce throughput.
-  # * <tt>:read_size</tt> - the maximum number of bytes to read at a time
-  #   from the source. Increasing this value might improve throughput. It
-  #   defaults to 32,000 bytes.
-  #
-  # == Progress Monitoring
-  #
-  # Sometimes it is desirable to track the progress of a download. There are
-  # two ways to do this: either using a callback block, or a special custom
-  # object.
-  #
-  # Using a block it's pretty straightforward:
-  #
-  #   sftp.download!("remote", "local") do |event, downloader, *args|
-  #     case event
-  #     when :open then
-  #       # args[0] : file metadata
-  #       puts "starting download: #{args[0].remote} -> #{args[0].local} (#{args[0].size} bytes}"
-  #     when :get then
-  #       # args[0] : file metadata
-  #       # args[1] : byte offset in remote file
-  #       # args[2] : data that was received
-  #       puts "writing #{args[2].length} bytes to #{args[0].local} starting at #{args[1]}"
-  #     when :close then
-  #       # args[0] : file metadata
-  #       puts "finished with #{args[0].remote}"
-  #     when :mkdir then
-  #       # args[0] : local path name
-  #       puts "creating directory #{args[0]}"
-  #     when :finish then
-  #       puts "all done!"
-  #   end
-  #
-  # However, for more complex implementations (e.g., GUI interfaces and such)
-  # a block can become cumbersome. In those cases, you can create custom
-  # handler objects that respond to certain methods, and then pass your handler
-  # to the downloader:
-  #
-  #   class CustomHandler
-  #     def on_open(downloader, file)
-  #       puts "starting download: #{file.remote} -> #{file.local} (#{file.size} bytes)"
-  #     end
-  #
-  #     def on_get(downloader, file, offset, data)
-  #       puts "writing #{data.length} bytes to #{file.local} starting at #{offset}"
-  #     end
-  #
-  #     def on_close(downloader, file)
-  #       puts "finished with #{file.remote}"
-  #     end
-  #
-  #     def on_mkdir(downloader, path)
-  #       puts "creating directory #{path}"
-  #     end
-  #
-  #     def on_finish(downloader)
-  #       puts "all done!"
-  #     end
-  #   end
-  #
-  #   sftp.download!("remote", "local", :progress => CustomHandler.new)
-  #
-  # If you omit any of those methods, the progress updates for those missing
-  # events will be ignored. You can create a catchall method named "call" for
-  # those, instead.
-  class Download
-    include Net::SSH::Loggable
-
-    # The destination of the download (the name of a file or directory on
-    # the local server, or an IO object)
-    attr_reader :local
-
-    # The source of the download (the name of a file or directory on the
-    # remote server)
-    attr_reader :remote
-
-    # The hash of options that was given to this Download instance.
-    attr_reader :options
-
-    # The SFTP session instance that drives this download.
-    attr_reader :sftp
-
-    # The properties hash for this object
-    attr_reader :properties
-
-    # Instantiates a new downloader process on top of the given SFTP session.
-    # +local+ is either an IO object that should receive the data, or a string
-    # identifying the target file or directory on the local host. +remote+ is
-    # a string identifying the location on the remote host that the download
-    # should source.
-    #
-    # This will return immediately, and requires that the SSH event loop be
-    # run in order to effect the download. (See #wait.)
-    def initialize(sftp, local, remote, options={}, &progress)
-      @sftp = sftp
-      @local = local
-      @remote = remote
-      @progress = progress || options[:progress]
-      @options = options
-      @active = 0
-      @properties = options[:properties] || {}
-
-      self.logger = sftp.logger
-
-      if recursive? && local.respond_to?(:write)
-        raise ArgumentError, "cannot download a directory tree in-memory"
-      end
-
-      @stack = [Entry.new(remote, local, recursive?)]
-      process_next_entry
-    end
-
-    # Returns the value of the :recursive key in the options hash that was
-    # given when the object was instantiated.
-    def recursive?
-      options[:recursive]
-    end
-
-    # Returns true if there are any active requests or pending files or
-    # directories.
-    def active?
-      @active > 0 || stack.any?
-    end
-
-    # Forces the transfer to stop.
-    def abort!
-      @active = 0
-      @stack.clear
-    end
-
-    # Runs the SSH event loop for as long as the downloader is active (see
-    # #active?). This can be used to block until the download completes.
-    def wait
-      sftp.loop { active? }
-      self
-    end
-
-    # Returns the property with the given name. This allows Download instances
-    # to store their own state when used as part of a state machine.
-    def [](name)
-      @properties[name.to_sym]
-    end
-
-    # Sets the given property to the given name. This allows Download instances
-    # to store their own state when used as part of a state machine.
-    def []=(name, value)
-      @properties[name.to_sym] = value
-    end
-
-    private
-
-      # A simple struct for encapsulating information about a single remote
-      # file or directory that needs to be downloaded.
-      Entry = Struct.new(:remote, :local, :directory, :size, :handle, :offset, :sink)
-
-      #--
-      # "ruby -w" hates private attributes, so we have to do these longhand
-      #++
-
-      # The stack of Entry instances, indicating which files and directories
-      # on the remote host remain to be downloaded.
-      def stack; @stack; end
-
-      # The progress handler for this instance. Possibly nil.
-      def progress; @progress; end
-
-      # The default read size.
-      DEFAULT_READ_SIZE = 32_000
-
-      # The number of bytes to read at a time from remote files.
-      def read_size
-        options[:read_size] || DEFAULT_READ_SIZE
-      end
-
-      # The number of simultaneou SFTP requests to use to effect the download.
-      # Defaults to 16 for recursive downloads.
-      def requests
-        options[:requests] || (recursive? ? 16 : 2)
-      end
-
-      # Enqueues as many files and directories from the stack as possible
-      # (see #requests).
-      def process_next_entry
-        while stack.any? && requests > @active
-          entry = stack.shift
-          @active += 1
-
-          if entry.directory
-            update_progress(:mkdir, entry.local)
-            ::Dir.mkdir(entry.local) unless ::File.directory?(entry.local)
-            request = sftp.opendir(entry.remote, &method(:on_opendir))
-            request[:entry] = entry
-          else
-            open_file(entry)
-          end
-        end
-
-        update_progress(:finish) if !active?
-      end
-
-      # Called when a remote directory is "opened" for reading, e.g. to
-      # enumerate its contents. Starts an readdir operation if the opendir
-      # operation was successful.
-      def on_opendir(response)
-        entry = response.request[:entry]
-        raise "opendir #{entry.remote}: #{response}" unless response.ok?
-        entry.handle = response[:handle]
-        request = sftp.readdir(response[:handle], &method(:on_readdir))
-        request[:parent] = entry
-      end
-
-      # Called when the next batch of items is read from a directory on the
-      # remote server. If any items were read, they are added to the queue
-      # and #process_next_entry is called.
-      def on_readdir(response)
-        entry = response.request[:parent]
-        if response.eof?
-          request = sftp.close(entry.handle, &method(:on_closedir))
-          request[:parent] = entry
-        elsif !response.ok?
-          raise "readdir #{entry.remote}: #{response}"
-        else
-          response[:names].each do |item|
-            next if item.name == "." || item.name == ".."
-            stack << Entry.new(::File.join(entry.remote, item.name), ::File.join(entry.local, item.name), item.directory?, item.attributes.size)
-          end
-
-          # take this opportunity to enqueue more requests
-          process_next_entry
-
-          request = sftp.readdir(entry.handle, &method(:on_readdir))
-          request[:parent] = entry
-        end
-      end
-
-      # Called when a file is to be opened for reading from the remote server.
-      def open_file(entry)
-        update_progress(:open, entry)
-        request = sftp.open(entry.remote, &method(:on_open))
-        request[:entry] = entry
-      end
-
-      # Called when a directory handle is closed.
-      def on_closedir(response)
-        @active -= 1
-        entry = response.request[:parent]
-        raise "close #{entry.remote}: #{response}" unless response.ok?
-        process_next_entry
-      end
-
-      # Called when a file has been opened. This will call #download_next_chunk
-      # to initiate the data transfer.
-      def on_open(response)
-        entry = response.request[:entry]
-        raise "open #{entry.remote}: #{response}" unless response.ok?
-
-        entry.handle = response[:handle]
-        entry.sink = entry.local.respond_to?(:write) ? entry.local : ::File.open(entry.local, "wb")
-        entry.offset = 0
-
-        download_next_chunk(entry)
-      end
-
-      # Initiates a read of the next #read_size bytes from the file.
-      def download_next_chunk(entry)
-        request = sftp.read(entry.handle, entry.offset, read_size, &method(:on_read))
-        request[:entry] = entry
-        request[:offset] = entry.offset
-        entry.offset += read_size
-      end
-
-      # Called when a read from a file finishes. If the read was successful
-      # and returned data, this will call #download_next_chunk to read the
-      # next bit from the file. Otherwise the file will be closed.
-      def on_read(response)
-        entry = response.request[:entry]
-
-        if response.eof?
-          update_progress(:close, entry)
-          entry.sink.close
-          request = sftp.close(entry.handle, &method(:on_close))
-          request[:entry] = entry
-        elsif !response.ok?
-          raise "read #{entry.remote}: #{response}"
-        else
-          update_progress(:get, entry, response.request[:offset], response[:data])
-          entry.sink.write(response[:data])
-          download_next_chunk(entry)
-        end
-      end
-
-      # Called when a file handle is closed.
-      def on_close(response)
-        @active -= 1
-        entry = response.request[:entry]
-        raise "close #{entry.remote}: #{response}" unless response.ok?
-        process_next_entry
-      end
-
-      # If a progress callback or object has been set, this will report
-      # the progress to that callback or object.
-      def update_progress(hook, *args)
-        on = "on_#{hook}"
-        if progress.respond_to?(on)
-          progress.send(on, self, *args)
-        elsif progress.respond_to?(:call)
-          progress.call(hook, self, *args)
-        end
-      end
-  end
-
-end; end; end