depengine 0.0.31 → 3.0.0

data/etc/isolate/jruby-1.8/gems/net-sftp-2.0.4/lib/net/sftp/packet.rb

@@ -1,21 +0,0 @@
-require 'net/ssh/buffer'
-
-module Net; module SFTP
-
-  # A specialization of the Net::SSH::Buffer class, which simply auto-reads
-  # the type byte from the front of every packet it represents.
-  class Packet < Net::SSH::Buffer
-    # The (intger) type of this packet. See Net::SFTP::Constants for all
-    # possible packet types.
-    attr_reader :type
-
-    # Create a new Packet object that wraps the given +data+ (which should be
-    # a String). The first byte of the data will be consumed automatically and
-    # interpreted as the #type of this packet.
-    def initialize(data)
-      super
-      @type = read_byte
-    end
-  end
-
-end; end

data/etc/isolate/jruby-1.8/gems/net-sftp-2.0.4/lib/net/sftp/protocol.rb

@@ -1,32 +0,0 @@
-require 'net/sftp/protocol/01/base'
-require 'net/sftp/protocol/02/base'
-require 'net/sftp/protocol/03/base'
-require 'net/sftp/protocol/04/base'
-require 'net/sftp/protocol/05/base'
-require 'net/sftp/protocol/06/base'
-
-module Net; module SFTP
-
-  # The Protocol module contains the definitions for all supported SFTP
-  # protocol versions.
-  module Protocol
-
-    # Instantiates and returns a new protocol driver instance for the given
-    # protocol version. +session+ must be a valid SFTP session object, and
-    # +version+ must be an integer. If an unsupported version is given,
-    # an exception will be raised.
-    def self.load(session, version)
-      case version
-      when 1 then V01::Base.new(session)
-      when 2 then V02::Base.new(session)
-      when 3 then V03::Base.new(session)
-      when 4 then V04::Base.new(session)
-      when 5 then V05::Base.new(session)
-      when 6 then V06::Base.new(session)
-      else raise NotImplementedError, "unsupported SFTP version #{version.inspect}"
-      end
-    end
-
-  end
-
-end; end

data/etc/isolate/jruby-1.8/gems/net-sftp-2.0.4/lib/net/sftp/protocol/01/attributes.rb

@@ -1,315 +0,0 @@
-require 'net/ssh/buffer'
-
-module Net; module SFTP; module Protocol; module V01
-
-  # A class representing the attributes of a file or directory on the server.
-  # It may be used to specify new attributes, or to query existing attributes.
-  #
-  # To specify new attributes, just pass a hash as the argument to the
-  # constructor. The following keys are supported:
-  #
-  # * :size:: the size of the file
-  # * :uid:: the user-id that owns the file (integer)
-  # * :gid:: the group-id that owns the file (integer)
-  # * :owner:: the name of the user that owns the file (string)
-  # * :group:: the name of the group that owns the file (string)
-  # * :permissions:: the permissions on the file (integer, e.g. 0755)
-  # * :atime:: the access time of the file (integer, seconds since epoch)
-  # * :mtime:: the modification time of the file (integer, seconds since epoch)
-  # * :extended:: a hash of name/value pairs identifying extended info
-  #
-  # Likewise, when the server sends an Attributes object, all of the
-  # above attributes are exposed as methods (though not all will be set with
-  # non-nil values from the server).
-  class Attributes
-
-    F_SIZE        = 0x00000001
-    F_UIDGID      = 0x00000002
-    F_PERMISSIONS = 0x00000004
-    F_ACMODTIME   = 0x00000008
-    F_EXTENDED    = 0x80000000
-
-    T_REGULAR      = 1
-    T_DIRECTORY    = 2
-    T_SYMLINK      = 3
-    T_SPECIAL      = 4
-    T_UNKNOWN      = 5
-    T_SOCKET       = 6
-    T_CHAR_DEVICE  = 7
-    T_BLOCK_DEVICE = 8
-    T_FIFO         = 9
-
-    class <<self
-      # Returns the array of attribute meta-data that defines the structure of
-      # the attributes packet as described by this version of the protocol.
-      def elements #:nodoc:
-        @elements ||= [
-          [:size,                :int64,   F_SIZE],
-          [:uid,                 :long,    F_UIDGID],
-          [:gid,                 :long,    F_UIDGID],
-          [:permissions,         :long,    F_PERMISSIONS],
-          [:atime,               :long,    F_ACMODTIME],
-          [:mtime,               :long,    F_ACMODTIME],
-          [:extended,            :special, F_EXTENDED]
-        ]
-      end
-
-      # Parses the given buffer and returns an Attributes object compsed from
-      # the data extracted from it.
-      def from_buffer(buffer)
-        flags = buffer.read_long
-        data = {}
-
-        elements.each do |name, type, condition|
-          if flags & condition == condition
-            if type == :special
-              data[name] = send("parse_#{name}", buffer)
-            else
-              data[name] = buffer.send("read_#{type}")
-            end
-          end
-        end
-
-        new(data)
-      end
-
-      # A convenience method for defining methods that expose specific
-      # attributes. This redefines the standard attr_accessor (an admittedly
-      # bad practice) because (1) I don't need any "regular" accessors, and
-      # (2) because rdoc will automatically pick up and note methods defined
-      # via attr_accessor.
-      def attr_accessor(name) #:nodoc:
-        class_eval <<-CODE
-          def #{name}
-            attributes[:#{name}]
-          end
-        CODE
-
-        attr_writer(name)
-      end
-
-      # A convenience method for defining methods that expose specific
-      # attributes. This redefines the standard attr_writer (an admittedly
-      # bad practice) because (1) I don't need any "regular" accessors, and
-      # (2) because rdoc will automatically pick up and note methods defined
-      # via attr_writer.
-      def attr_writer(name) #:nodoc:
-        class_eval <<-CODE
-          def #{name}=(value)
-            attributes[:#{name}] = value
-          end
-        CODE
-      end
-
-      private
-
-        # Parse the hash of extended data from the buffer.
-        def parse_extended(buffer)
-          extended = Hash.new
-          buffer.read_long.times do
-            extended[buffer.read_string] = buffer.read_string
-          end
-          extended
-        end
-    end
-
-    # The hash of name/value pairs that backs this Attributes instance
-    attr_reader   :attributes
-
-    # The size of the file.
-    attr_accessor :size
-
-    # The user-id of the user that owns the file
-    attr_writer   :uid
-
-    # The group-id of the user that owns the file
-    attr_writer   :gid
-
-    # The permissions on the file
-    attr_accessor :permissions
-
-    # The last access time of the file
-    attr_accessor :atime
-
-    # The modification time of the file
-    attr_accessor :mtime
-
-    # The hash of name/value pairs identifying extended information about the file
-    attr_accessor :extended
-
-    # Create a new Attributes instance with the given attributes. The
-    # following keys are supported:
-    #
-    # * :size:: the size of the file
-    # * :uid:: the user-id that owns the file (integer)
-    # * :gid:: the group-id that owns the file (integer)
-    # * :owner:: the name of the user that owns the file (string)
-    # * :group:: the name of the group that owns the file (string)
-    # * :permissions:: the permissions on the file (integer, e.g. 0755)
-    # * :atime:: the access time of the file (integer, seconds since epoch)
-    # * :mtime:: the modification time of the file (integer, seconds since epoch)
-    # * :extended:: a hash of name/value pairs identifying extended info
-    def initialize(attributes={})
-      @attributes = attributes
-    end
-
-    # Returns the user-id of the user that owns the file, or +nil+ if that
-    # information is not available. If an :owner key exists, but not a :uid
-    # key, the Etc module will be used to reverse lookup the id from the name.
-    # This might fail on some systems (e.g., Windows).
-    def uid
-      if attributes[:owner] && !attributes.key?(:uid)
-        require 'etc'
-        attributes[:uid] = Etc.getpwnam(attributes[:owner]).uid
-      end
-      attributes[:uid]
-    end
-
-    # Returns the group-id of the group that owns the file, or +nil+ if that
-    # information is not available. If a :group key exists, but not a :gid
-    # key, the Etc module will be used to reverse lookup the id from the name.
-    # This might fail on some systems (e.g., Windows).
-    def gid
-      if attributes[:group] && !attributes.key?(:gid)
-        require 'etc'
-        attributes[:gid] = Etc.getgrnam(attributes[:group]).gid
-      end
-      attributes[:gid]
-    end
-
-    # Returns the username of the user that owns the file, or +nil+ if that
-    # information is not available. If the :uid is given, but not the :owner,
-    # the Etc module will be used to lookup the name from the id. This might
-    # fail on some systems (e.g. Windows).
-    def owner
-      if attributes[:uid] && !attributes[:owner]
-        require 'etc'
-        attributes[:owner] = Etc.getpwuid(attributes[:uid].to_i).name
-      end
-      attributes[:owner]
-    end
-
-    # Returns the group name of the group that owns the file, or +nil+ if that
-    # information is not available. If the :gid is given, but not the :group,
-    # the Etc module will be used to lookup the name from the id. This might
-    # fail on some systems (e.g. Windows).
-    def group
-      if attributes[:gid] && !attributes[:group]
-        require 'etc'
-        attributes[:group] = Etc.getgrgid(attributes[:gid].to_i).name
-      end
-      attributes[:group]
-    end
-
-    # Inspects the permissions bits to determine what type of entity this
-    # attributes object represents. If will return one of the T_ constants.
-    def type
-      if    permissions & 0140000 == 0140000 then 
-        T_SOCKET
-      elsif permissions & 0120000 == 0120000 then 
-        T_SYMLINK
-      elsif permissions & 0100000 == 0100000 then
-        T_REGULAR
-      elsif permissions &  060000 ==  060000 then
-        T_BLOCK_DEVICE
-      elsif permissions &  040000 ==  040000 then
-        T_DIRECTORY
-      elsif permissions &  020000 ==  020000 then
-        T_CHAR_DEVICE
-      elsif permissions &  010000 ==  010000 then
-        T_FIFO
-      else
-        T_UNKNOWN
-      end
-    end
-
-    # Returns the type as a symbol, rather than an integer, for easier use in
-    # Ruby programs.
-    def symbolic_type
-      case type
-      when T_SOCKET       then :socket
-      when T_SYMLINK      then :symlink
-      when T_REGULAR      then :regular
-      when T_BLOCK_DEVICE then :block_device
-      when T_DIRECTORY    then :directory
-      when T_CHAR_DEVICE  then :char_device
-      when T_FIFO         then :fifo
-      when T_SPECIAL      then :special
-      when T_UNKNOWN      then :unknown
-      else raise NotImplementedError, "unknown file type #{type} (bug?)"
-      end
-    end
-
-    # Returns true if these attributes appear to describe a directory.
-    def directory?
-      case type
-      when T_DIRECTORY then true
-      when T_UNKNOWN   then nil
-      else false
-      end
-    end
-
-    # Returns true if these attributes appear to describe a symlink.
-    def symlink?
-      case type
-      when T_SYMLINK then true
-      when T_UNKNOWN then nil
-      else false
-      end
-    end
-
-    # Returns true if these attributes appear to describe a regular file.
-    def file?
-      case type
-      when T_REGULAR then true
-      when T_UNKNOWN then nil
-      else false
-      end
-    end
-
-    # Convert the object to a string suitable for passing in an SFTP
-    # packet. This is the raw representation of the attribute packet payload,
-    # and is not intended to be human readable.
-    def to_s
-      prepare_serialization!
-
-      flags = 0
-
-      self.class.elements.each do |name, type, condition|
-        flags |= condition if attributes[name]
-      end
-
-      buffer = Net::SSH::Buffer.from(:long, flags)
-      self.class.elements.each do |name, type, condition|
-        if flags & condition == condition
-          if type == :special
-            send("encode_#{name}", buffer)
-          else
-            buffer.send("write_#{type}", attributes[name])
-          end
-        end
-      end
-
-      buffer.to_s
-    end
-
-    private
-
-      # Perform protocol-version-specific preparations for serialization.
-      def prepare_serialization!
-        # force the uid/gid to be translated from owner/group, if those keys
-        # were given on instantiation
-        uid
-        gid
-      end
-
-      # Encodes information about the extended info onto the end of the given
-      # buffer.
-      def encode_extended(buffer)
-        buffer.write_long extended.size
-        extended.each { |k,v| buffer.write_string k, v }
-      end
-
-  end
-
-end ; end ; end ; end

data/etc/isolate/jruby-1.8/gems/net-sftp-2.0.4/lib/net/sftp/protocol/01/base.rb

@@ -1,268 +0,0 @@
-require 'net/ssh/loggable'
-require 'net/sftp/constants'
-require 'net/sftp/packet'
-require 'net/sftp/protocol/base'
-require 'net/sftp/protocol/01/attributes'
-require 'net/sftp/protocol/01/name'
-
-module Net; module SFTP; module Protocol; module V01
-
-  # Wraps the low-level SFTP calls for version 1 of the SFTP protocol. Also
-  # implements the packet parsing as defined by version 1 of the protocol.
-  #
-  # None of these protocol methods block--all of them return immediately,
-  # requiring the SSH event loop to be run while the server response is
-  # pending.
-  #
-  # You will almost certainly never need to use this driver directly. Please
-  # see Net::SFTP::Session for the recommended interface.
-  class Base < Protocol::Base
-    include Net::SFTP::Constants::OpenFlags
-
-    # Returns the protocol version implemented by this driver. (1, in this
-    # case)
-    def version
-      1
-    end
-
-    # Parses the given FXP_HANDLE packet and returns a hash with one key,
-    # :handle, which references the handle.
-    def parse_handle_packet(packet)
-      { :handle => packet.read_string }
-    end
-
-    # Parses the given FXP_STATUS packet and returns a hash with one key,
-    # :code, which references the status code returned by the server.
-    def parse_status_packet(packet)
-      { :code => packet.read_long }
-    end
-
-    # Parses the given FXP_DATA packet and returns a hash with one key,
-    # :data, which references the data returned in the packet.
-    def parse_data_packet(packet)
-      { :data => packet.read_string }
-    end
-
-    # Parses the given FXP_ATTRS packet and returns a hash with one key,
-    # :attrs, which references an Attributes object.
-    def parse_attrs_packet(packet)
-      { :attrs => attribute_factory.from_buffer(packet) }
-    end
-
-    # Parses the given FXP_NAME packet and returns a hash with one key, :names,
-    # which references an array of Name objects.
-    def parse_name_packet(packet)
-      names = []
-
-      packet.read_long.times do
-        filename = packet.read_string
-        longname = packet.read_string
-        attrs    = attribute_factory.from_buffer(packet)
-        names   << name_factory.new(filename, longname, attrs)
-      end
-
-      { :names => names }
-    end
-
-    # Sends a FXP_OPEN packet to the server and returns the packet identifier.
-    # The +flags+ parameter is either an integer (in which case it must be
-    # a combination of the IO constants) or a string (in which case it must
-    # be one of the mode strings that IO::open accepts). The +options+
-    # parameter is a hash that is used to construct a new Attribute object,
-    # to pass as part of the FXP_OPEN request.
-    def open(path, flags, options)
-      flags = normalize_open_flags(flags)
-
-      if flags & (IO::WRONLY | IO::RDWR) != 0
-        sftp_flags = FV1::WRITE
-        sftp_flags |= FV1::READ if flags & IO::RDWR != 0
-        sftp_flags |= FV1::APPEND if flags & IO::APPEND != 0
-      else
-        sftp_flags = FV1::READ
-      end
-
-      sftp_flags |= FV1::CREAT if flags & IO::CREAT != 0
-      sftp_flags |= FV1::TRUNC if flags & IO::TRUNC != 0
-      sftp_flags |= FV1::EXCL  if flags & IO::EXCL  != 0
-
-      attributes = attribute_factory.new(options)
-
-      send_request(FXP_OPEN, :string, path, :long, sftp_flags, :raw, attributes.to_s)
-    end
-
-    # Sends a FXP_CLOSE packet to the server for the given +handle+ (such as
-    # would be returned via a FXP_HANDLE packet). Returns the new packet id.
-    def close(handle)
-      send_request(FXP_CLOSE, :string, handle)
-    end
-
-    # Sends a FXP_READ packet to the server, requesting that +length+ bytes
-    # be read from the file identified by +handle+, starting at +offset+ bytes
-    # within the file. The handle must be one that was returned via a
-    # FXP_HANDLE packet. Returns the new packet id.
-    def read(handle, offset, length)
-      send_request(FXP_READ, :string, handle, :int64, offset, :long, length)
-    end
-
-    # Sends a FXP_WRITE packet to the server, requesting that +data+ (a string),
-    # be written to the file identified by +handle+, starting at +offset+ bytes
-    # from the beginning of the file. The handle must be one that was returned
-    # via a FXP_HANDLE packet. Returns the new packet id.
-    def write(handle, offset, data)
-      send_request(FXP_WRITE, :string, handle, :int64, offset, :string, data)
-    end
-
-    # Sends a FXP_LSTAT packet to the server, requesting a FXP_ATTR response
-    # for the file at the given remote +path+ (a string). The +flags+ parameter
-    # is ignored in this version of the protocol. #lstat will not follow
-    # symbolic links; see #stat for a version that will.
-    def lstat(path, flags=nil)
-      send_request(FXP_LSTAT, :string, path)
-    end
-
-    # Sends a FXP_FSTAT packet to the server, requesting a FXP_ATTR response
-    # for the file represented by the given +handle+ (which must have been
-    # obtained from a FXP_HANDLE packet). The +flags+ parameter is ignored in
-    # this version of the protocol.
-    def fstat(handle, flags=nil)
-      send_request(FXP_FSTAT, :string, handle)
-    end
-
-    # Sends a FXP_SETSTAT packet to the server, to update the attributes for
-    # the file at the given remote +path+ (a string). The +attrs+ parameter is
-    # a hash that defines the attributes to set.
-    def setstat(path, attrs)
-      send_request(FXP_SETSTAT, :string, path, :raw, attribute_factory.new(attrs).to_s)
-    end
-
-    # Sends a FXP_FSETSTAT packet to the server, to update the attributes for
-    # the file represented by the given +handle+ (which must have been obtained
-    # from a FXP_HANDLE packet). The +attrs+ parameter is a hash that defines
-    # the attributes to set.
-    def fsetstat(handle, attrs)
-      send_request(FXP_FSETSTAT, :string, handle, :raw, attribute_factory.new(attrs).to_s)
-    end
-
-    # Sends a FXP_OPENDIR packet to the server, to request a handle for
-    # manipulating the directory at the given remote +path+.
-    def opendir(path)
-      send_request(FXP_OPENDIR, :string, path)
-    end
-
-    # Sends a FXP_READDIR packet to the server, to request a batch of
-    # directory name entries in the directory identified by +handle+ (which
-    # must have been obtained via a FXP_OPENDIR request).
-    def readdir(handle)
-      send_request(FXP_READDIR, :string, handle)
-    end
-
-    # Sends a FXP_REMOTE packet to the server, to request that the given
-    # file be deleted from the remote server.
-    def remove(filename)
-      send_request(FXP_REMOVE, :string, filename)
-    end
-
-    # Sends a FXP_MKDIR packet to the server, to request that a new directory
-    # at +path+ on the remote server be created, and with +attrs+ (a hash)
-    # describing the attributes of the new directory.
-    def mkdir(path, attrs)
-      send_request(FXP_MKDIR, :string, path, :raw, attribute_factory.new(attrs).to_s)
-    end
-
-    # Sends a FXP_RMDIR packet to the server, to request that the directory
-    # at +path+ on the remote server be deleted.
-    def rmdir(path)
-      send_request(FXP_RMDIR, :string, path)
-    end
-
-    # Sends a FXP_REALPATH packet to the server, to request that the given
-    # +path+ be canonicalized, taking into account path segments like "..".
-    def realpath(path)
-      send_request(FXP_REALPATH, :string, path)
-    end
-
-    # Sends a FXP_STAT packet to the server, requesting a FXP_ATTR response
-    # for the file at the given remote +path+ (a string). The +flags+ parameter
-    # is ignored in this version of the protocol. #stat will follow
-    # symbolic links; see #lstat for a version that will not.
-    def stat(path, flags=nil)
-      send_request(FXP_STAT, :string, path)
-    end
-
-    # Not implemented in version 1 of the SFTP protocol. Raises a
-    # NotImplementedError if called.
-    def rename(name, new_name, flags=nil)
-      not_implemented! :rename
-    end
-
-    # Not implemented in version 1 of the SFTP protocol. Raises a
-    # NotImplementedError if called.
-    def readlink(path)
-      not_implemented! :readlink
-    end
-
-    # Not implemented in version 1 of the SFTP protocol. Raises a
-    # NotImplementedError if called.
-    def symlink(path, target)
-      not_implemented! :symlink
-    end
-
-    # Not implemented in version 1 of the SFTP protocol. Raises a
-    # NotImplementedError if called.
-    def link(*args)
-      not_implemented! :link
-    end
-
-    # Not implemented in version 1 of the SFTP protocol. Raises a
-    # NotImplementedError if called.
-    def block(handle, offset, length, mask)
-      not_implemented! :block
-    end
-
-    # Not implemented in version 1 of the SFTP protocol. Raises a
-    # NotImplementedError if called.
-    def unblock(handle, offset, length)
-      not_implemented! :unblock
-    end
-
-    protected
-
-      # A helper method for implementing wrappers for operations that are
-      # not implemented by the current SFTP protocol version. Simply raises
-      # NotImplementedError with a message based on the given operation name.
-      def not_implemented!(operation)
-        raise NotImplementedError, "the #{operation} operation is not available in the version of the SFTP protocol supported by your server"
-      end
-
-      # Normalizes the given flags parameter, converting it into a combination
-      # of IO constants.
-      def normalize_open_flags(flags)
-        if String === flags
-          case flags.tr("b", "")
-          when "r"  then IO::RDONLY
-          when "r+" then IO::RDWR
-          when "w"  then IO::WRONLY | IO::TRUNC | IO::CREAT
-          when "w+" then IO::RDWR | IO::TRUNC | IO::CREAT
-          when "a"  then IO::APPEND | IO::CREAT | IO::WRONLY
-          when "a+" then IO::APPEND | IO::CREAT | IO::RDWR
-          else raise ArgumentError, "unsupported flags: #{flags.inspect}"
-          end
-        else
-          flags.to_i
-        end
-      end
-
-      # Returns the Attributes class used by this version of the protocol
-      # (Net::SFTP::Protocol::V01::Attributes, in this case)
-      def attribute_factory
-        V01::Attributes
-      end
-
-      # Returns the Name class used by this version of the protocol
-      # (Net::SFTP::Protocol::V01::Name, in this case)
-      def name_factory
-        V01::Name
-      end
-  end
-
-end; end; end; end