second_step 0.1.2 → 0.1.3

data/secondstep-notify-1.0.0-osx/lib/ruby/lib/ruby/2.2.0/monitor.rb

@@ -1,300 +0,0 @@
-# = monitor.rb
-#
-# Copyright (C) 2001  Shugo Maeda <shugo@ruby-lang.org>
-#
-# This library is distributed under the terms of the Ruby license.
-# You can freely distribute/modify this library.
-#
-
-require 'thread'
-
-#
-# In concurrent programming, a monitor is an object or module intended to be
-# used safely by more than one thread.  The defining characteristic of a
-# monitor is that its methods are executed with mutual exclusion.  That is, at
-# each point in time, at most one thread may be executing any of its methods.
-# This mutual exclusion greatly simplifies reasoning about the implementation
-# of monitors compared to reasoning about parallel code that updates a data
-# structure.
-#
-# You can read more about the general principles on the Wikipedia page for
-# Monitors[http://en.wikipedia.org/wiki/Monitor_%28synchronization%29]
-#
-# == Examples
-#
-# === Simple object.extend
-#
-#   require 'monitor.rb'
-#
-#   buf = []
-#   buf.extend(MonitorMixin)
-#   empty_cond = buf.new_cond
-#
-#   # consumer
-#   Thread.start do
-#     loop do
-#       buf.synchronize do
-#         empty_cond.wait_while { buf.empty? }
-#         print buf.shift
-#       end
-#     end
-#   end
-#
-#   # producer
-#   while line = ARGF.gets
-#     buf.synchronize do
-#       buf.push(line)
-#       empty_cond.signal
-#     end
-#   end
-#
-# The consumer thread waits for the producer thread to push a line to buf
-# while <tt>buf.empty?</tt>.  The producer thread (main thread) reads a
-# line from ARGF and pushes it into buf then calls <tt>empty_cond.signal</tt>
-# to notify the consumer thread of new data.
-#
-# === Simple Class include
-#
-#   require 'monitor'
-#
-#   class SynchronizedArray < Array
-#
-#     include MonitorMixin
-#
-#     def initialize(*args)
-#       super(*args)
-#     end
-#
-#     alias :old_shift :shift
-#     alias :old_unshift :unshift
-#
-#     def shift(n=1)
-#       self.synchronize do
-#         self.old_shift(n)
-#       end
-#     end
-#
-#     def unshift(item)
-#       self.synchronize do
-#         self.old_unshift(item)
-#       end
-#     end
-#
-#     # other methods ...
-#   end
-#
-# +SynchronizedArray+ implements an Array with synchronized access to items.
-# This Class is implemented as subclass of Array which includes the
-# MonitorMixin module.
-#
-module MonitorMixin
-  #
-  # FIXME: This isn't documented in Nutshell.
-  #
-  # Since MonitorMixin.new_cond returns a ConditionVariable, and the example
-  # above calls while_wait and signal, this class should be documented.
-  #
-  class ConditionVariable
-    class Timeout < Exception; end
-
-    #
-    # Releases the lock held in the associated monitor and waits; reacquires the lock on wakeup.
-    #
-    # If +timeout+ is given, this method returns after +timeout+ seconds passed,
-    # even if no other thread doesn't signal.
-    #
-    def wait(timeout = nil)
-      @monitor.__send__(:mon_check_owner)
-      count = @monitor.__send__(:mon_exit_for_cond)
-      begin
-        @cond.wait(@monitor.instance_variable_get(:@mon_mutex), timeout)
-        return true
-      ensure
-        @monitor.__send__(:mon_enter_for_cond, count)
-      end
-    end
-
-    #
-    # Calls wait repeatedly while the given block yields a truthy value.
-    #
-    def wait_while
-      while yield
-        wait
-      end
-    end
-
-    #
-    # Calls wait repeatedly until the given block yields a truthy value.
-    #
-    def wait_until
-      until yield
-        wait
-      end
-    end
-
-    #
-    # Wakes up the first thread in line waiting for this lock.
-    #
-    def signal
-      @monitor.__send__(:mon_check_owner)
-      @cond.signal
-    end
-
-    #
-    # Wakes up all threads waiting for this lock.
-    #
-    def broadcast
-      @monitor.__send__(:mon_check_owner)
-      @cond.broadcast
-    end
-
-    private
-
-    def initialize(monitor)
-      @monitor = monitor
-      @cond = ::ConditionVariable.new
-    end
-  end
-
-  def self.extend_object(obj)
-    super(obj)
-    obj.__send__(:mon_initialize)
-  end
-
-  #
-  # Attempts to enter exclusive section.  Returns +false+ if lock fails.
-  #
-  def mon_try_enter
-    if @mon_owner != Thread.current
-      unless @mon_mutex.try_lock
-        return false
-      end
-      @mon_owner = Thread.current
-    end
-    @mon_count += 1
-    return true
-  end
-  # For backward compatibility
-  alias try_mon_enter mon_try_enter
-
-  #
-  # Enters exclusive section.
-  #
-  def mon_enter
-    if @mon_owner != Thread.current
-      @mon_mutex.lock
-      @mon_owner = Thread.current
-    end
-    @mon_count += 1
-  end
-
-  #
-  # Leaves exclusive section.
-  #
-  def mon_exit
-    mon_check_owner
-    @mon_count -=1
-    if @mon_count == 0
-      @mon_owner = nil
-      @mon_mutex.unlock
-    end
-  end
-
-  #
-  # Enters exclusive section and executes the block.  Leaves the exclusive
-  # section automatically when the block exits.  See example under
-  # +MonitorMixin+.
-  #
-  def mon_synchronize
-    mon_enter
-    begin
-      yield
-    ensure
-      mon_exit
-    end
-  end
-  alias synchronize mon_synchronize
-
-  #
-  # Creates a new MonitorMixin::ConditionVariable associated with the
-  # receiver.
-  #
-  def new_cond
-    return ConditionVariable.new(self)
-  end
-
-  private
-
-  # Use <tt>extend MonitorMixin</tt> or <tt>include MonitorMixin</tt> instead
-  # of this constructor.  Have look at the examples above to understand how to
-  # use this module.
-  def initialize(*args)
-    super
-    mon_initialize
-  end
-
-  # Initializes the MonitorMixin after being included in a class or when an
-  # object has been extended with the MonitorMixin
-  def mon_initialize
-    @mon_owner = nil
-    @mon_count = 0
-    @mon_mutex = Mutex.new
-  end
-
-  def mon_check_owner
-    if @mon_owner != Thread.current
-      raise ThreadError, "current thread not owner"
-    end
-  end
-
-  def mon_enter_for_cond(count)
-    @mon_owner = Thread.current
-    @mon_count = count
-  end
-
-  def mon_exit_for_cond
-    count = @mon_count
-    @mon_owner = nil
-    @mon_count = 0
-    return count
-  end
-end
-
-# Use the Monitor class when you want to have a lock object for blocks with
-# mutual exclusion.
-#
-#   require 'monitor'
-#
-#   lock = Monitor.new
-#   lock.synchronize do
-#     # exclusive access
-#   end
-#
-class Monitor
-  include MonitorMixin
-  alias try_enter try_mon_enter
-  alias enter mon_enter
-  alias exit mon_exit
-end
-
-
-# Documentation comments:
-#  - All documentation comes from Nutshell.
-#  - MonitorMixin.new_cond appears in the example, but is not documented in
-#    Nutshell.
-#  - All the internals (internal modules Accessible and Initializable, class
-#    ConditionVariable) appear in RDoc.  It might be good to hide them, by
-#    making them private, or marking them :nodoc:, etc.
-#  - RDoc doesn't recognise aliases, so we have mon_synchronize documented, but
-#    not synchronize.
-#  - mon_owner is in Nutshell, but appears as an accessor in a separate module
-#    here, so is hard/impossible to RDoc.  Some other useful accessors
-#    (mon_count and some queue stuff) are also in this module, and don't appear
-#    directly in the RDoc output.
-#  - in short, it may be worth changing the code layout in this file to make the
-#    documentation easier
-
-# Local variables:
-# mode: Ruby
-# tab-width: 8
-# End:

data/secondstep-notify-1.0.0-osx/lib/ruby/lib/ruby/2.2.0/mutex_m.rb

@@ -1,111 +0,0 @@
-#
-#   mutex_m.rb -
-#       $Release Version: 3.0$
-#       $Revision: 1.7 $
-#       Original from mutex.rb
-#       by Keiju ISHITSUKA(keiju@ishitsuka.com)
-#       modified by matz
-#       patched by akira yamada
-#
-# --
-
-
-require 'thread'
-
-# = mutex_m.rb
-#
-# When 'mutex_m' is required, any object that extends or includes Mutex_m will
-# be treated like a Mutex.
-#
-# Start by requiring the standard library Mutex_m:
-#
-#   require "mutex_m.rb"
-#
-# From here you can extend an object with Mutex instance methods:
-#
-#   obj = Object.new
-#   obj.extend Mutex_m
-#
-# Or mixin Mutex_m into your module to your class inherit Mutex instance
-# methods.
-#
-#   class Foo
-#     include Mutex_m
-#     # ...
-#   end
-#   obj = Foo.new
-#   # this obj can be handled like Mutex
-#
-module Mutex_m
-  def Mutex_m.define_aliases(cl) # :nodoc:
-    cl.module_eval %q{
-      alias locked? mu_locked?
-      alias lock mu_lock
-      alias unlock mu_unlock
-      alias try_lock mu_try_lock
-      alias synchronize mu_synchronize
-    }
-  end
-
-  def Mutex_m.append_features(cl) # :nodoc:
-    super
-    define_aliases(cl) unless cl.instance_of?(Module)
-  end
-
-  def Mutex_m.extend_object(obj) # :nodoc:
-    super
-    obj.mu_extended
-  end
-
-  def mu_extended # :nodoc:
-    unless (defined? locked? and
-            defined? lock and
-            defined? unlock and
-            defined? try_lock and
-            defined? synchronize)
-      Mutex_m.define_aliases(singleton_class)
-    end
-    mu_initialize
-  end
-
-  # See Mutex#synchronize
-  def mu_synchronize(&block)
-    @_mutex.synchronize(&block)
-  end
-
-  # See Mutex#locked?
-  def mu_locked?
-    @_mutex.locked?
-  end
-
-  # See Mutex#try_lock
-  def mu_try_lock
-    @_mutex.try_lock
-  end
-
-  # See Mutex#lock
-  def mu_lock
-    @_mutex.lock
-  end
-
-  # See Mutex#unlock
-  def mu_unlock
-    @_mutex.unlock
-  end
-
-  # See Mutex#sleep
-  def sleep(timeout = nil)
-    @_mutex.sleep(timeout)
-  end
-
-  private
-
-  def mu_initialize # :nodoc:
-    @_mutex = Mutex.new
-  end
-
-  def initialize(*args) # :nodoc:
-    mu_initialize
-    super
-  end
-end

data/secondstep-notify-1.0.0-osx/lib/ruby/lib/ruby/2.2.0/net/ftp.rb

@@ -1,1126 +0,0 @@
-#
-# = net/ftp.rb - FTP Client Library
-#
-# Written by Shugo Maeda <shugo@ruby-lang.org>.
-#
-# Documentation by Gavin Sinclair, sourced from "Programming Ruby" (Hunt/Thomas)
-# and "Ruby In a Nutshell" (Matsumoto), used with permission.
-#
-# This library is distributed under the terms of the Ruby license.
-# You can freely distribute/modify this library.
-#
-# It is included in the Ruby standard library.
-#
-# See the Net::FTP class for an overview.
-#
-
-require "socket"
-require "monitor"
-require "net/protocol"
-
-module Net
-
-  # :stopdoc:
-  class FTPError < StandardError; end
-  class FTPReplyError < FTPError; end
-  class FTPTempError < FTPError; end
-  class FTPPermError < FTPError; end
-  class FTPProtoError < FTPError; end
-  class FTPConnectionError < FTPError; end
-  # :startdoc:
-
-  #
-  # This class implements the File Transfer Protocol.  If you have used a
-  # command-line FTP program, and are familiar with the commands, you will be
-  # able to use this class easily.  Some extra features are included to take
-  # advantage of Ruby's style and strengths.
-  #
-  # == Example
-  #
-  #   require 'net/ftp'
-  #
-  # === Example 1
-  #
-  #   ftp = Net::FTP.new('example.com')
-  #   ftp.login
-  #   files = ftp.chdir('pub/lang/ruby/contrib')
-  #   files = ftp.list('n*')
-  #   ftp.getbinaryfile('nif.rb-0.91.gz', 'nif.gz', 1024)
-  #   ftp.close
-  #
-  # === Example 2
-  #
-  #   Net::FTP.open('example.com') do |ftp|
-  #     ftp.login
-  #     files = ftp.chdir('pub/lang/ruby/contrib')
-  #     files = ftp.list('n*')
-  #     ftp.getbinaryfile('nif.rb-0.91.gz', 'nif.gz', 1024)
-  #   end
-  #
-  # == Major Methods
-  #
-  # The following are the methods most likely to be useful to users:
-  # - FTP.open
-  # - #getbinaryfile
-  # - #gettextfile
-  # - #putbinaryfile
-  # - #puttextfile
-  # - #chdir
-  # - #nlst
-  # - #size
-  # - #rename
-  # - #delete
-  #
-  class FTP
-    include MonitorMixin
-
-    # :stopdoc:
-    FTP_PORT = 21
-    CRLF = "\r\n"
-    DEFAULT_BLOCKSIZE = BufferedIO::BUFSIZE
-    # :startdoc:
-
-    # When +true+, transfers are performed in binary mode.  Default: +true+.
-    attr_reader :binary
-
-    # When +true+, the connection is in passive mode.  Default: +false+.
-    attr_accessor :passive
-
-    # When +true+, all traffic to and from the server is written
-    # to +$stdout+.  Default: +false+.
-    attr_accessor :debug_mode
-
-    # Sets or retrieves the +resume+ status, which decides whether incomplete
-    # transfers are resumed or restarted.  Default: +false+.
-    attr_accessor :resume
-
-    # Number of seconds to wait for the connection to open. Any number
-    # may be used, including Floats for fractional seconds. If the FTP
-    # object cannot open a connection in this many seconds, it raises a
-    # Net::OpenTimeout exception. The default value is +nil+.
-    attr_accessor :open_timeout
-
-    # Number of seconds to wait for one block to be read (via one read(2)
-    # call). Any number may be used, including Floats for fractional
-    # seconds. If the FTP object cannot read data in this many seconds,
-    # it raises a Timeout::Error exception. The default value is 60 seconds.
-    attr_reader :read_timeout
-
-    # Setter for the read_timeout attribute.
-    def read_timeout=(sec)
-      @sock.read_timeout = sec
-      @read_timeout = sec
-    end
-
-    # The server's welcome message.
-    attr_reader :welcome
-
-    # The server's last response code.
-    attr_reader :last_response_code
-    alias lastresp last_response_code
-
-    # The server's last response.
-    attr_reader :last_response
-
-    #
-    # A synonym for <tt>FTP.new</tt>, but with a mandatory host parameter.
-    #
-    # If a block is given, it is passed the +FTP+ object, which will be closed
-    # when the block finishes, or when an exception is raised.
-    #
-    def FTP.open(host, user = nil, passwd = nil, acct = nil)
-      if block_given?
-        ftp = new(host, user, passwd, acct)
-        begin
-          yield ftp
-        ensure
-          ftp.close
-        end
-      else
-        new(host, user, passwd, acct)
-      end
-    end
-
-    #
-    # Creates and returns a new +FTP+ object. If a +host+ is given, a connection
-    # is made. Additionally, if the +user+ is given, the given user name,
-    # password, and (optionally) account are used to log in.  See #login.
-    #
-    def initialize(host = nil, user = nil, passwd = nil, acct = nil)
-      super()
-      @binary = true
-      @passive = false
-      @debug_mode = false
-      @resume = false
-      @sock = NullSocket.new
-      @logged_in = false
-      @open_timeout = nil
-      @read_timeout = 60
-      if host
-        connect(host)
-        if user
-          login(user, passwd, acct)
-        end
-      end
-    end
-
-    # A setter to toggle transfers in binary mode.
-    # +newmode+ is either +true+ or +false+
-    def binary=(newmode)
-      if newmode != @binary
-        @binary = newmode
-        send_type_command if @logged_in
-      end
-    end
-
-    # Sends a command to destination host, with the current binary sendmode
-    # type.
-    #
-    # If binary mode is +true+, then "TYPE I" (image) is sent, otherwise "TYPE
-    # A" (ascii) is sent.
-    def send_type_command # :nodoc:
-      if @binary
-        voidcmd("TYPE I")
-      else
-        voidcmd("TYPE A")
-      end
-    end
-    private :send_type_command
-
-    # Toggles transfers in binary mode and yields to a block.
-    # This preserves your current binary send mode, but allows a temporary
-    # transaction with binary sendmode of +newmode+.
-    #
-    # +newmode+ is either +true+ or +false+
-    def with_binary(newmode) # :nodoc:
-      oldmode = binary
-      self.binary = newmode
-      begin
-        yield
-      ensure
-        self.binary = oldmode
-      end
-    end
-    private :with_binary
-
-    # Obsolete
-    def return_code # :nodoc:
-      $stderr.puts("warning: Net::FTP#return_code is obsolete and do nothing")
-      return "\n"
-    end
-
-    # Obsolete
-    def return_code=(s) # :nodoc:
-      $stderr.puts("warning: Net::FTP#return_code= is obsolete and do nothing")
-    end
-
-    # Constructs a socket with +host+ and +port+.
-    #
-    # If SOCKSSocket is defined and the environment (ENV) defines
-    # SOCKS_SERVER, then a SOCKSSocket is returned, else a TCPSocket is
-    # returned.
-    def open_socket(host, port) # :nodoc:
-      return Timeout.timeout(@open_timeout, Net::OpenTimeout) {
-        if defined? SOCKSSocket and ENV["SOCKS_SERVER"]
-          @passive = true
-          sock = SOCKSSocket.open(host, port)
-        else
-          sock = TCPSocket.open(host, port)
-        end
-        io = BufferedSocket.new(sock)
-        io.read_timeout = @read_timeout
-        io
-      }
-    end
-    private :open_socket
-
-    #
-    # Establishes an FTP connection to host, optionally overriding the default
-    # port. If the environment variable +SOCKS_SERVER+ is set, sets up the
-    # connection through a SOCKS proxy. Raises an exception (typically
-    # <tt>Errno::ECONNREFUSED</tt>) if the connection cannot be established.
-    #
-    def connect(host, port = FTP_PORT)
-      if @debug_mode
-        print "connect: ", host, ", ", port, "\n"
-      end
-      synchronize do
-        @sock = open_socket(host, port)
-        voidresp
-      end
-    end
-
-    #
-    # Set the socket used to connect to the FTP server.
-    #
-    # May raise FTPReplyError if +get_greeting+ is false.
-    def set_socket(sock, get_greeting = true)
-      synchronize do
-        @sock = sock
-        if get_greeting
-          voidresp
-        end
-      end
-    end
-
-    # If string +s+ includes the PASS command (password), then the contents of
-    # the password are cleaned from the string using "*"
-    def sanitize(s) # :nodoc:
-      if s =~ /^PASS /i
-        return s[0, 5] + "*" * (s.length - 5)
-      else
-        return s
-      end
-    end
-    private :sanitize
-
-    # Ensures that +line+ has a control return / line feed (CRLF) and writes
-    # it to the socket.
-    def putline(line) # :nodoc:
-      if @debug_mode
-        print "put: ", sanitize(line), "\n"
-      end
-      line = line + CRLF
-      @sock.write(line)
-    end
-    private :putline
-
-    # Reads a line from the sock.  If EOF, then it will raise EOFError
-    def getline # :nodoc:
-      line = @sock.readline # if get EOF, raise EOFError
-      line.sub!(/(\r\n|\n|\r)\z/n, "")
-      if @debug_mode
-        print "get: ", sanitize(line), "\n"
-      end
-      return line
-    end
-    private :getline
-
-    # Receive a section of lines until the response code's match.
-    def getmultiline # :nodoc:
-      line = getline
-      buff = line
-      if line[3] == ?-
-          code = line[0, 3]
-        begin
-          line = getline
-          buff << "\n" << line
-        end until line[0, 3] == code and line[3] != ?-
-      end
-      return buff << "\n"
-    end
-    private :getmultiline
-
-    # Receives a response from the destination host.
-    #
-    # Returns the response code or raises FTPTempError, FTPPermError, or
-    # FTPProtoError
-    def getresp # :nodoc:
-      @last_response = getmultiline
-      @last_response_code = @last_response[0, 3]
-      case @last_response_code
-      when /\A[123]/
-        return @last_response
-      when /\A4/
-        raise FTPTempError, @last_response
-      when /\A5/
-        raise FTPPermError, @last_response
-      else
-        raise FTPProtoError, @last_response
-      end
-    end
-    private :getresp
-
-    # Receives a response.
-    #
-    # Raises FTPReplyError if the first position of the response code is not
-    # equal 2.
-    def voidresp # :nodoc:
-      resp = getresp
-      if resp[0] != ?2
-        raise FTPReplyError, resp
-      end
-    end
-    private :voidresp
-
-    #
-    # Sends a command and returns the response.
-    #
-    def sendcmd(cmd)
-      synchronize do
-        putline(cmd)
-        return getresp
-      end
-    end
-
-    #
-    # Sends a command and expect a response beginning with '2'.
-    #
-    def voidcmd(cmd)
-      synchronize do
-        putline(cmd)
-        voidresp
-      end
-    end
-
-    # Constructs and send the appropriate PORT (or EPRT) command
-    def sendport(host, port) # :nodoc:
-      af = (@sock.peeraddr)[0]
-      if af == "AF_INET"
-        cmd = "PORT " + (host.split(".") + port.divmod(256)).join(",")
-      elsif af == "AF_INET6"
-        cmd = sprintf("EPRT |2|%s|%d|", host, port)
-      else
-        raise FTPProtoError, host
-      end
-      voidcmd(cmd)
-    end
-    private :sendport
-
-    # Constructs a TCPServer socket, and sends it the PORT command
-    #
-    # Returns the constructed TCPServer socket
-    def makeport # :nodoc:
-      sock = TCPServer.open(@sock.addr[3], 0)
-      port = sock.addr[1]
-      host = sock.addr[3]
-      sendport(host, port)
-      return sock
-    end
-    private :makeport
-
-    # sends the appropriate command to enable a passive connection
-    def makepasv # :nodoc:
-      if @sock.peeraddr[0] == "AF_INET"
-        host, port = parse227(sendcmd("PASV"))
-      else
-        host, port = parse229(sendcmd("EPSV"))
-        #     host, port = parse228(sendcmd("LPSV"))
-      end
-      return host, port
-    end
-    private :makepasv
-
-    # Constructs a connection for transferring data
-    def transfercmd(cmd, rest_offset = nil) # :nodoc:
-      if @passive
-        host, port = makepasv
-        conn = open_socket(host, port)
-        if @resume and rest_offset
-          resp = sendcmd("REST " + rest_offset.to_s)
-          if resp[0] != ?3
-            raise FTPReplyError, resp
-          end
-        end
-        resp = sendcmd(cmd)
-        # skip 2XX for some ftp servers
-        resp = getresp if resp[0] == ?2
-        if resp[0] != ?1
-          raise FTPReplyError, resp
-        end
-      else
-        sock = makeport
-        begin
-          if @resume and rest_offset
-            resp = sendcmd("REST " + rest_offset.to_s)
-            if resp[0] != ?3
-              raise FTPReplyError, resp
-            end
-          end
-          resp = sendcmd(cmd)
-          # skip 2XX for some ftp servers
-          resp = getresp if resp[0] == ?2
-          if resp[0] != ?1
-            raise FTPReplyError, resp
-          end
-          conn = BufferedSocket.new(sock.accept)
-          conn.read_timeout = @read_timeout
-          sock.shutdown(Socket::SHUT_WR) rescue nil
-          sock.read rescue nil
-        ensure
-          sock.close
-        end
-      end
-      return conn
-    end
-    private :transfercmd
-
-    #
-    # Logs in to the remote host.  The session must have been
-    # previously connected.  If +user+ is the string "anonymous" and
-    # the +password+ is +nil+, "anonymous@" is used as a password.  If
-    # the +acct+ parameter is not +nil+, an FTP ACCT command is sent
-    # following the successful login.  Raises an exception on error
-    # (typically <tt>Net::FTPPermError</tt>).
-    #
-    def login(user = "anonymous", passwd = nil, acct = nil)
-      if user == "anonymous" and passwd == nil
-        passwd = "anonymous@"
-      end
-
-      resp = ""
-      synchronize do
-        resp = sendcmd('USER ' + user)
-        if resp[0] == ?3
-          raise FTPReplyError, resp if passwd.nil?
-          resp = sendcmd('PASS ' + passwd)
-        end
-        if resp[0] == ?3
-          raise FTPReplyError, resp if acct.nil?
-          resp = sendcmd('ACCT ' + acct)
-        end
-      end
-      if resp[0] != ?2
-        raise FTPReplyError, resp
-      end
-      @welcome = resp
-      send_type_command
-      @logged_in = true
-    end
-
-    #
-    # Puts the connection into binary (image) mode, issues the given command,
-    # and fetches the data returned, passing it to the associated block in
-    # chunks of +blocksize+ characters. Note that +cmd+ is a server command
-    # (such as "RETR myfile").
-    #
-    def retrbinary(cmd, blocksize, rest_offset = nil) # :yield: data
-      synchronize do
-        with_binary(true) do
-          begin
-            conn = transfercmd(cmd, rest_offset)
-            loop do
-              data = conn.read(blocksize)
-              break if data == nil
-              yield(data)
-            end
-            conn.shutdown(Socket::SHUT_WR)
-            conn.read_timeout = 1
-            conn.read
-          ensure
-            conn.close if conn
-          end
-          voidresp
-        end
-      end
-    end
-
-    #
-    # Puts the connection into ASCII (text) mode, issues the given command, and
-    # passes the resulting data, one line at a time, to the associated block. If
-    # no block is given, prints the lines. Note that +cmd+ is a server command
-    # (such as "RETR myfile").
-    #
-    def retrlines(cmd) # :yield: line
-      synchronize do
-        with_binary(false) do
-          begin
-            conn = transfercmd(cmd)
-            loop do
-              line = conn.gets
-              break if line == nil
-              yield(line.sub(/\r?\n\z/, ""), !line.match(/\n\z/).nil?)
-            end
-            conn.shutdown(Socket::SHUT_WR)
-            conn.read_timeout = 1
-            conn.read
-          ensure
-            conn.close if conn
-          end
-          voidresp
-        end
-      end
-    end
-
-    #
-    # Puts the connection into binary (image) mode, issues the given server-side
-    # command (such as "STOR myfile"), and sends the contents of the file named
-    # +file+ to the server. If the optional block is given, it also passes it
-    # the data, in chunks of +blocksize+ characters.
-    #
-    def storbinary(cmd, file, blocksize, rest_offset = nil) # :yield: data
-      if rest_offset
-        file.seek(rest_offset, IO::SEEK_SET)
-      end
-      synchronize do
-        with_binary(true) do
-          conn = transfercmd(cmd)
-          loop do
-            buf = file.read(blocksize)
-            break if buf == nil
-            conn.write(buf)
-            yield(buf) if block_given?
-          end
-          conn.close
-          voidresp
-        end
-      end
-    rescue Errno::EPIPE
-      # EPIPE, in this case, means that the data connection was unexpectedly
-      # terminated.  Rather than just raising EPIPE to the caller, check the
-      # response on the control connection.  If getresp doesn't raise a more
-      # appropriate exception, re-raise the original exception.
-      getresp
-      raise
-    end
-
-    #
-    # Puts the connection into ASCII (text) mode, issues the given server-side
-    # command (such as "STOR myfile"), and sends the contents of the file
-    # named +file+ to the server, one line at a time. If the optional block is
-    # given, it also passes it the lines.
-    #
-    def storlines(cmd, file) # :yield: line
-      synchronize do
-        with_binary(false) do
-          conn = transfercmd(cmd)
-          loop do
-            buf = file.gets
-            break if buf == nil
-            if buf[-2, 2] != CRLF
-              buf = buf.chomp + CRLF
-            end
-            conn.write(buf)
-            yield(buf) if block_given?
-          end
-          conn.close
-          voidresp
-        end
-      end
-    rescue Errno::EPIPE
-      # EPIPE, in this case, means that the data connection was unexpectedly
-      # terminated.  Rather than just raising EPIPE to the caller, check the
-      # response on the control connection.  If getresp doesn't raise a more
-      # appropriate exception, re-raise the original exception.
-      getresp
-      raise
-    end
-
-    #
-    # Retrieves +remotefile+ in binary mode, storing the result in +localfile+.
-    # If +localfile+ is nil, returns retrieved data.
-    # If a block is supplied, it is passed the retrieved data in +blocksize+
-    # chunks.
-    #
-    def getbinaryfile(remotefile, localfile = File.basename(remotefile),
-                      blocksize = DEFAULT_BLOCKSIZE) # :yield: data
-      result = nil
-      if localfile
-        if @resume
-          rest_offset = File.size?(localfile)
-          f = open(localfile, "a")
-        else
-          rest_offset = nil
-          f = open(localfile, "w")
-        end
-      elsif !block_given?
-        result = ""
-      end
-      begin
-        f.binmode if localfile
-        retrbinary("RETR " + remotefile.to_s, blocksize, rest_offset) do |data|
-          f.write(data) if localfile
-          yield(data) if block_given?
-          result.concat(data) if result
-        end
-        return result
-      ensure
-        f.close if localfile
-      end
-    end
-
-    #
-    # Retrieves +remotefile+ in ASCII (text) mode, storing the result in
-    # +localfile+.
-    # If +localfile+ is nil, returns retrieved data.
-    # If a block is supplied, it is passed the retrieved data one
-    # line at a time.
-    #
-    def gettextfile(remotefile, localfile = File.basename(remotefile)) # :yield: line
-      result = nil
-      if localfile
-        f = open(localfile, "w")
-      elsif !block_given?
-        result = ""
-      end
-      begin
-        retrlines("RETR " + remotefile) do |line, newline|
-          l = newline ? line + "\n" : line
-          f.print(l) if localfile
-          yield(line, newline) if block_given?
-          result.concat(l) if result
-        end
-        return result
-      ensure
-        f.close if localfile
-      end
-    end
-
-    #
-    # Retrieves +remotefile+ in whatever mode the session is set (text or
-    # binary).  See #gettextfile and #getbinaryfile.
-    #
-    def get(remotefile, localfile = File.basename(remotefile),
-            blocksize = DEFAULT_BLOCKSIZE, &block) # :yield: data
-      if @binary
-        getbinaryfile(remotefile, localfile, blocksize, &block)
-      else
-        gettextfile(remotefile, localfile, &block)
-      end
-    end
-
-    #
-    # Transfers +localfile+ to the server in binary mode, storing the result in
-    # +remotefile+. If a block is supplied, calls it, passing in the transmitted
-    # data in +blocksize+ chunks.
-    #
-    def putbinaryfile(localfile, remotefile = File.basename(localfile),
-                      blocksize = DEFAULT_BLOCKSIZE, &block) # :yield: data
-      if @resume
-        begin
-          rest_offset = size(remotefile)
-        rescue Net::FTPPermError
-          rest_offset = nil
-        end
-      else
-        rest_offset = nil
-      end
-      f = open(localfile)
-      begin
-        f.binmode
-        if rest_offset
-          storbinary("APPE " + remotefile, f, blocksize, rest_offset, &block)
-        else
-          storbinary("STOR " + remotefile, f, blocksize, rest_offset, &block)
-        end
-      ensure
-        f.close
-      end
-    end
-
-    #
-    # Transfers +localfile+ to the server in ASCII (text) mode, storing the result
-    # in +remotefile+. If callback or an associated block is supplied, calls it,
-    # passing in the transmitted data one line at a time.
-    #
-    def puttextfile(localfile, remotefile = File.basename(localfile), &block) # :yield: line
-      f = open(localfile)
-      begin
-        storlines("STOR " + remotefile, f, &block)
-      ensure
-        f.close
-      end
-    end
-
-    #
-    # Transfers +localfile+ to the server in whatever mode the session is set
-    # (text or binary).  See #puttextfile and #putbinaryfile.
-    #
-    def put(localfile, remotefile = File.basename(localfile),
-            blocksize = DEFAULT_BLOCKSIZE, &block)
-      if @binary
-        putbinaryfile(localfile, remotefile, blocksize, &block)
-      else
-        puttextfile(localfile, remotefile, &block)
-      end
-    end
-
-    #
-    # Sends the ACCT command.
-    #
-    # This is a less common FTP command, to send account
-    # information if the destination host requires it.
-    #
-    def acct(account)
-      cmd = "ACCT " + account
-      voidcmd(cmd)
-    end
-
-    #
-    # Returns an array of filenames in the remote directory.
-    #
-    def nlst(dir = nil)
-      cmd = "NLST"
-      if dir
-        cmd = cmd + " " + dir
-      end
-      files = []
-      retrlines(cmd) do |line|
-        files.push(line)
-      end
-      return files
-    end
-
-    #
-    # Returns an array of file information in the directory (the output is like
-    # `ls -l`).  If a block is given, it iterates through the listing.
-    #
-    def list(*args, &block) # :yield: line
-      cmd = "LIST"
-      args.each do |arg|
-        cmd = cmd + " " + arg.to_s
-      end
-      if block
-        retrlines(cmd, &block)
-      else
-        lines = []
-        retrlines(cmd) do |line|
-          lines << line
-        end
-        return lines
-      end
-    end
-    alias ls list
-    alias dir list
-
-    #
-    # Renames a file on the server.
-    #
-    def rename(fromname, toname)
-      resp = sendcmd("RNFR " + fromname)
-      if resp[0] != ?3
-        raise FTPReplyError, resp
-      end
-      voidcmd("RNTO " + toname)
-    end
-
-    #
-    # Deletes a file on the server.
-    #
-    def delete(filename)
-      resp = sendcmd("DELE " + filename)
-      if resp[0, 3] == "250"
-        return
-      elsif resp[0] == ?5
-        raise FTPPermError, resp
-      else
-        raise FTPReplyError, resp
-      end
-    end
-
-    #
-    # Changes the (remote) directory.
-    #
-    def chdir(dirname)
-      if dirname == ".."
-        begin
-          voidcmd("CDUP")
-          return
-        rescue FTPPermError => e
-          if e.message[0, 3] != "500"
-            raise e
-          end
-        end
-      end
-      cmd = "CWD " + dirname
-      voidcmd(cmd)
-    end
-
-    #
-    # Returns the size of the given (remote) filename.
-    #
-    def size(filename)
-      with_binary(true) do
-        resp = sendcmd("SIZE " + filename)
-        if resp[0, 3] != "213"
-          raise FTPReplyError, resp
-        end
-        return resp[3..-1].strip.to_i
-      end
-    end
-
-    MDTM_REGEXP = /^(\d\d\d\d)(\d\d)(\d\d)(\d\d)(\d\d)(\d\d)/  # :nodoc:
-
-    #
-    # Returns the last modification time of the (remote) file.  If +local+ is
-    # +true+, it is returned as a local time, otherwise it's a UTC time.
-    #
-    def mtime(filename, local = false)
-      str = mdtm(filename)
-      ary = str.scan(MDTM_REGEXP)[0].collect {|i| i.to_i}
-      return local ? Time.local(*ary) : Time.gm(*ary)
-    end
-
-    #
-    # Creates a remote directory.
-    #
-    def mkdir(dirname)
-      resp = sendcmd("MKD " + dirname)
-      return parse257(resp)
-    end
-
-    #
-    # Removes a remote directory.
-    #
-    def rmdir(dirname)
-      voidcmd("RMD " + dirname)
-    end
-
-    #
-    # Returns the current remote directory.
-    #
-    def pwd
-      resp = sendcmd("PWD")
-      return parse257(resp)
-    end
-    alias getdir pwd
-
-    #
-    # Returns system information.
-    #
-    def system
-      resp = sendcmd("SYST")
-      if resp[0, 3] != "215"
-        raise FTPReplyError, resp
-      end
-      return resp[4 .. -1]
-    end
-
-    #
-    # Aborts the previous command (ABOR command).
-    #
-    def abort
-      line = "ABOR" + CRLF
-      print "put: ABOR\n" if @debug_mode
-      @sock.send(line, Socket::MSG_OOB)
-      resp = getmultiline
-      unless ["426", "226", "225"].include?(resp[0, 3])
-        raise FTPProtoError, resp
-      end
-      return resp
-    end
-
-    #
-    # Returns the status (STAT command).
-    #
-    def status
-      line = "STAT" + CRLF
-      print "put: STAT\n" if @debug_mode
-      @sock.send(line, Socket::MSG_OOB)
-      return getresp
-    end
-
-    #
-    # Returns the raw last modification time of the (remote) file in the format
-    # "YYYYMMDDhhmmss" (MDTM command).
-    #
-    # Use +mtime+ if you want a parsed Time instance.
-    #
-    def mdtm(filename)
-      resp = sendcmd("MDTM " + filename)
-      if resp[0, 3] == "213"
-        return resp[3 .. -1].strip
-      end
-    end
-
-    #
-    # Issues the HELP command.
-    #
-    def help(arg = nil)
-      cmd = "HELP"
-      if arg
-        cmd = cmd + " " + arg
-      end
-      sendcmd(cmd)
-    end
-
-    #
-    # Exits the FTP session.
-    #
-    def quit
-      voidcmd("QUIT")
-    end
-
-    #
-    # Issues a NOOP command.
-    #
-    # Does nothing except return a response.
-    #
-    def noop
-      voidcmd("NOOP")
-    end
-
-    #
-    # Issues a SITE command.
-    #
-    def site(arg)
-      cmd = "SITE " + arg
-      voidcmd(cmd)
-    end
-
-    #
-    # Closes the connection.  Further operations are impossible until you open
-    # a new connection with #connect.
-    #
-    def close
-      if @sock and not @sock.closed?
-        begin
-          @sock.shutdown(Socket::SHUT_WR) rescue nil
-          orig, self.read_timeout = self.read_timeout, 3
-          @sock.read rescue nil
-        ensure
-          @sock.close
-          self.read_timeout = orig
-        end
-      end
-    end
-
-    #
-    # Returns +true+ iff the connection is closed.
-    #
-    def closed?
-      @sock == nil or @sock.closed?
-    end
-
-    # handler for response code 227
-    # (Entering Passive Mode (h1,h2,h3,h4,p1,p2))
-    #
-    # Returns host and port.
-    def parse227(resp) # :nodoc:
-      if resp[0, 3] != "227"
-        raise FTPReplyError, resp
-      end
-      if m = /\((?<host>\d+(,\d+){3}),(?<port>\d+,\d+)\)/.match(resp)
-        return parse_pasv_ipv4_host(m["host"]), parse_pasv_port(m["port"])
-      else
-        raise FTPProtoError, resp
-      end
-    end
-    private :parse227
-
-    # handler for response code 228
-    # (Entering Long Passive Mode)
-    #
-    # Returns host and port.
-    def parse228(resp) # :nodoc:
-      if resp[0, 3] != "228"
-        raise FTPReplyError, resp
-      end
-      if m = /\(4,4,(?<host>\d+(,\d+){3}),2,(?<port>\d+,\d+)\)/.match(resp)
-        return parse_pasv_ipv4_host(m["host"]), parse_pasv_port(m["port"])
-      elsif m = /\(6,16,(?<host>\d+(,(\d+)){15}),2,(?<port>\d+,\d+)\)/.match(resp)
-        return parse_pasv_ipv6_host(m["host"]), parse_pasv_port(m["port"])
-      else
-        raise FTPProtoError, resp
-      end
-    end
-    private :parse228
-
-    def parse_pasv_ipv4_host(s)
-      return s.tr(",", ".")
-    end
-    private :parse_pasv_ipv4_host
-
-    def parse_pasv_ipv6_host(s)
-      return s.split(/,/).map { |i|
-        "%02x" % i.to_i
-      }.each_slice(2).map(&:join).join(":")
-    end
-    private :parse_pasv_ipv6_host
-
-    def parse_pasv_port(s)
-      return s.split(/,/).map(&:to_i).inject { |x, y|
-        (x << 8) + y
-      }
-    end
-    private :parse_pasv_port
-
-    # handler for response code 229
-    # (Extended Passive Mode Entered)
-    #
-    # Returns host and port.
-    def parse229(resp) # :nodoc:
-      if resp[0, 3] != "229"
-        raise FTPReplyError, resp
-      end
-      if m = /\((?<d>[!-~])\k<d>\k<d>(?<port>\d+)\k<d>\)/.match(resp)
-        return @sock.peeraddr[3], m["port"].to_i
-      else
-        raise FTPProtoError, resp
-      end
-    end
-    private :parse229
-
-    # handler for response code 257
-    # ("PATHNAME" created)
-    #
-    # Returns host and port.
-    def parse257(resp) # :nodoc:
-      if resp[0, 3] != "257"
-        raise FTPReplyError, resp
-      end
-      if resp[3, 2] != ' "'
-        return ""
-      end
-      dirname = ""
-      i = 5
-      n = resp.length
-      while i < n
-        c = resp[i, 1]
-        i = i + 1
-        if c == '"'
-          if i > n or resp[i, 1] != '"'
-            break
-          end
-          i = i + 1
-        end
-        dirname = dirname + c
-      end
-      return dirname
-    end
-    private :parse257
-
-    # :stopdoc:
-    class NullSocket
-      def read_timeout=(sec)
-      end
-
-      def close
-      end
-
-      def method_missing(mid, *args)
-        raise FTPConnectionError, "not connected"
-      end
-    end
-
-    class BufferedSocket < BufferedIO
-      [:addr, :peeraddr, :send, :shutdown].each do |method|
-        define_method(method) { |*args|
-          @io.__send__(method, *args)
-        }
-      end
-
-      def read(len = nil)
-        if len
-          s = super(len, "", true)
-          return s.empty? ? nil : s
-        else
-          result = ""
-          while s = super(DEFAULT_BLOCKSIZE, "", true)
-            break if s.empty?
-            result << s
-          end
-          return result
-        end
-      end
-
-      def gets
-        line = readuntil("\n", true)
-        return line.empty? ? nil : line
-      end
-
-      def readline
-        line = gets
-        if line.nil?
-          raise EOFError, "end of file reached"
-        end
-        return line
-      end
-    end
-    # :startdoc:
-  end
-end
-
-
-# Documentation comments:
-#  - sourced from pickaxe and nutshell, with improvements (hopefully)