mechanize 0.6.11 → 0.7.0

data/lib/mechanize/net-overrides/net/https.rb

@@ -1,172 +0,0 @@
-# :enddoc:
-=begin
-
-= $RCSfile: https.rb,v $ -- SSL/TLS enhancement for Net::HTTP.
-
-== Info
-  'OpenSSL for Ruby 2' project
-  Copyright (C) 2001 GOTOU Yuuzou <gotoyuzo@notwork.org>
-  All rights reserved.
-
-== Licence
-  This program is licenced under the same licence as Ruby.
-  (See the file 'LICENCE'.)
-
-== Requirements
-  This program requires Net 1.2.0 or higher version.
-  You can get it from RAA or Ruby's CVS repository.
-
-== Version
-  $Id: https.rb,v 1.3 2004/12/20 05:46:45 gotoyuzo Exp $
-  
-  2001-11-06: Contiributed to Ruby/OpenSSL project.
-  2004-03-06: Some code is merged in to net/http.
-
-== Example
-
-Here is a simple HTTP client:
-
-    require 'net/http'
-    require 'uri'
-
-    uri = URI.parse(ARGV[0] || 'http://localhost/')
-    http = Net::HTTP.new(uri.host, uri.port)
-    http.start {
-      http.request_get(uri.path) {|res|
-        print res.body
-      }
-    }
-
-It can be replaced by the following code:
-
-    require 'net/https'
-    require 'uri'
-
-    uri = URI.parse(ARGV[0] || 'https://localhost/')
-    http = Net::HTTP.new(uri.host, uri.port)
-    http.use_ssl = true if uri.scheme == "https"  # enable SSL/TLS
-    http.start {
-      http.request_get(uri.path) {|res|
-        print res.body
-      }
-    }
-
-== class Net::HTTP
-
-=== Instance Methods
-
-: use_ssl?
-    returns true if use SSL/TLS with HTTP.
-
-: use_ssl=((|true_or_false|))
-    sets use_ssl.
-
-: peer_cert
-    return the X.509 certificates the server presented.
-
-: key, key=((|key|))
-    Sets an OpenSSL::PKey::RSA or OpenSSL::PKey::DSA object.
-    (This method is appeared in Michal Rokos's OpenSSL extention.)
-
-: cert, cert=((|cert|))
-    Sets an OpenSSL::X509::Certificate object as client certificate
-    (This method is appeared in Michal Rokos's OpenSSL extention).
-
-: ca_file, ca_file=((|path|))
-    Sets path of a CA certification file in PEM format.
-    The file can contrain several CA certificats.
-
-: ca_path, ca_path=((|path|))
-    Sets path of a CA certification directory containing certifications
-    in PEM format.
-
-: verify_mode, verify_mode=((|mode|))
-    Sets the flags for server the certification verification at
-    begining of SSL/TLS session.
-    OpenSSL::SSL::VERIFY_NONE or OpenSSL::SSL::VERIFY_PEER is acceptable.
-
-: verify_callback, verify_callback=((|proc|))
-    Sets the verify callback for the server certification verification.
-
-: verify_depth, verify_depth=((|num|))
-    Sets the maximum depth for the certificate chain verification.
-
-: cert_store, cert_store=((|store|))
-    Sets the X509::Store to verify peer certificate.
-
-: ssl_timeout, ssl_timeout=((|sec|))
-    Sets the SSL timeout seconds.
-
-=end
-
-require 'net/http'
-require 'openssl'
-
-module Net
-
-  class HTTP
-    remove_method :use_ssl?
-    def use_ssl?
-      @use_ssl
-    end
-
-    alias use_ssl use_ssl?   # for backward compatibility
-
-    # Turn on/off SSL.
-    # This flag must be set before starting session.
-    # If you change use_ssl value after session started,
-    # a Net::HTTP object raises IOError.
-    def use_ssl=(flag)
-      flag = (flag ? true : false)
-      raise IOError, "use_ssl value changed, but session already started" \
-          if started? and @use_ssl != flag
-      if flag and not @ssl_context
-        @ssl_context = OpenSSL::SSL::SSLContext.new
-      end
-      @use_ssl = flag
-    end
-
-    def self.ssl_context_accessor(name)
-      module_eval(<<-End, __FILE__, __LINE__ + 1)
-        def #{name}
-          return nil unless @ssl_context
-          @ssl_context.#{name}
-        end
-
-        def #{name}=(val)
-          @ssl_context ||= OpenSSL::SSL::SSLContext.new
-          @ssl_context.#{name} = val
-        end
-      End
-    end
-
-    ssl_context_accessor :key
-    ssl_context_accessor :cert
-    ssl_context_accessor :ca_file
-    ssl_context_accessor :ca_path
-    ssl_context_accessor :verify_mode
-    ssl_context_accessor :verify_callback
-    ssl_context_accessor :verify_depth
-    ssl_context_accessor :cert_store
-
-    def ssl_timeout
-      return nil unless @ssl_context
-      @ssl_context.timeout
-    end
-
-    def ssl_timeout=(sec)
-      raise ArgumentError, 'Net::HTTP#ssl_timeout= called but use_ssl=false' \
-          unless use_ssl?
-      @ssl_context ||= OpenSSL::SSL::SSLContext.new
-      @ssl_context.timeout = sec
-    end
-
-    alias timeout= ssl_timeout=   # for backward compatibility
-
-    def peer_cert
-      return nil if not use_ssl? or not @socket
-      @socket.io.peer_cert
-    end
-  end
-
-end

data/lib/mechanize/net-overrides/net/protocol.rb

@@ -1,380 +0,0 @@
-# :enddoc:
-# = net/protocol.rb
-#
-#--
-# Copyright (c) 1999-2004 Yukihiro Matsumoto
-# Copyright (c) 1999-2004 Minero Aoki
-#
-# written and maintained by Minero Aoki <aamine@loveruby.net>
-#
-# This program is free software. You can re-distribute and/or
-# modify this program under the same terms as Ruby itself,
-# Ruby Distribute License or GNU General Public License.
-#
-# $Id: protocol.rb,v 1.78 2004/08/18 14:44:41 aamine Exp $
-#++
-#
-# WARNING: This file is going to remove.
-# Do not rely on the implementation written in this file.
-#
-
-require 'socket'
-require 'timeout'
-
-module Net # :nodoc:
-
-  class Protocol   #:nodoc: internal use only
-    private
-    def Protocol.protocol_param(name, val)
-      module_eval(<<-End, __FILE__, __LINE__ + 1)
-        def #{name}
-          #{val}
-        end
-      End
-    end
-  end
-
-
-  class ProtocolError          < StandardError; end
-  class ProtoSyntaxError       < ProtocolError; end
-  class ProtoFatalError        < ProtocolError; end
-  class ProtoUnknownError      < ProtocolError; end
-  class ProtoServerError       < ProtocolError; end
-  class ProtoAuthError         < ProtocolError; end
-  class ProtoCommandError      < ProtocolError; end
-  class ProtoRetriableError    < ProtocolError; end
-  ProtocRetryError = ProtoRetriableError
-
-
-  class BufferedIO   #:nodoc: internal use only
-    def initialize(io)
-      @io = io
-      @read_timeout = 60
-      @debug_output = nil
-      @rbuf = ''
-    end
-
-    attr_reader :io
-    attr_accessor :read_timeout
-    attr_accessor :debug_output
-
-    def inspect
-      "#<#{self.class} io=#{@io}>"
-    end
-
-    def closed?
-      @io.closed?
-    end
-
-    def close
-      @io.close
-    end
-
-    #
-    # Read
-    #
-
-    public
-
-    def read(len, dest = '', ignore_eof = false)
-      LOG "reading #{len} bytes..."
-      read_bytes = 0
-      begin
-        while read_bytes + @rbuf.size < len
-          dest << (s = rbuf_consume(@rbuf.size))
-          read_bytes += s.size
-          rbuf_fill
-        end
-        dest << (s = rbuf_consume(len - read_bytes))
-        read_bytes += s.size
-      rescue EOFError
-        raise unless ignore_eof
-      end
-      LOG "read #{read_bytes} bytes"
-      dest
-    end
-
-    def read_all(dest = '')
-      LOG 'reading all...'
-      read_bytes = 0
-      begin
-        while true
-          dest << (s = rbuf_consume(@rbuf.size))
-          read_bytes += s.size
-          rbuf_fill
-        end
-      rescue EOFError
-        ;
-      end
-      LOG "read #{read_bytes} bytes"
-      dest
-    end
-
-    def readuntil(terminator, ignore_eof = false)
-      begin
-        until idx = @rbuf.index(terminator)
-          rbuf_fill
-        end
-        return rbuf_consume(idx + terminator.size)
-      rescue EOFError
-        raise unless ignore_eof
-        return rbuf_consume(@rbuf.size)
-      end
-    end
-        
-    def readline
-      readuntil("\n").chop
-    end
-
-    private
-
-    def rbuf_fill
-      timeout(@read_timeout) {
-        @rbuf << @io.sysread(1024)
-      }
-    end
-
-    def rbuf_consume(len)
-      s = @rbuf.slice!(0, len)
-      @debug_output << %Q[-> #{s.dump}\n] if @debug_output
-      s
-    end
-
-    #
-    # Write
-    #
-
-    public
-
-    def write(str)
-      writing {
-        write0 str
-      }
-    end
-
-    def writeline(str)
-      writing {
-        write0 str + "\r\n"
-      }
-    end
-
-    private
-
-    def writing
-      @written_bytes = 0
-      @debug_output << '<- ' if @debug_output
-      yield
-      @debug_output << "\n" if @debug_output
-      bytes = @written_bytes
-      @written_bytes = nil
-      bytes
-    end
-
-    def write0(str)
-      @debug_output << str.dump if @debug_output
-      len = @io.write(str)
-      @written_bytes += len
-      len
-    end
-
-    #
-    # Logging
-    #
-
-    private
-
-    def LOG_off
-      @save_debug_out = @debug_output
-      @debug_output = nil
-    end
-
-    def LOG_on
-      @debug_output = @save_debug_out
-    end
-
-    def LOG(msg)
-      return unless @debug_output
-      @debug_output << msg + "\n"
-    end
-  end
-
-
-  class InternetMessageIO < BufferedIO   #:nodoc: internal use only
-    def initialize(io)
-      super
-      @wbuf = nil
-    end
-
-    #
-    # Read
-    #
-
-    def each_message_chunk
-      LOG 'reading message...'
-      LOG_off()
-      read_bytes = 0
-      while (line = readuntil("\r\n")) != ".\r\n"
-        read_bytes += line.size
-        yield line.sub(/\A\./, '')
-      end
-      LOG_on()
-      LOG "read message (#{read_bytes} bytes)"
-    end
-  
-    # *library private* (cannot handle 'break')
-    def each_list_item
-      while (str = readuntil("\r\n")) != ".\r\n"
-        yield str.chop
-      end
-    end
-
-    def write_message_0(src)
-      prev = @written_bytes
-      each_crlf_line(src) do |line|
-        write0 line.sub(/\A\./, '..')
-      end
-      @written_bytes - prev
-    end
-
-    #
-    # Write
-    #
-
-    def write_message(src)
-      LOG "writing message from #{src.class}"
-      LOG_off()
-      len = writing {
-        using_each_crlf_line {
-          write_message_0 src
-        }
-      }
-      LOG_on()
-      LOG "wrote #{len} bytes"
-      len
-    end
-
-    def write_message_by_block(&block)
-      LOG 'writing message from block'
-      LOG_off()
-      len = writing {
-        using_each_crlf_line {
-          begin
-            block.call(WriteAdapter.new(self, :write_message_0))
-          rescue LocalJumpError
-            # allow `break' from writer block
-          end
-        }
-      }
-      LOG_on()
-      LOG "wrote #{len} bytes"
-      len
-    end
-
-    private
-
-    def using_each_crlf_line
-      @wbuf = ''
-      yield
-      if not @wbuf.empty?   # unterminated last line
-        write0 @wbuf.chomp + "\r\n"
-      elsif @written_bytes == 0   # empty src
-        write0 "\r\n"
-      end
-      write0 ".\r\n"
-      @wbuf = nil
-    end
-
-    def each_crlf_line(src)
-      buffer_filling(@wbuf, src) do
-        while line = @wbuf.slice!(/\A.*(?:\n|\r\n|\r(?!\z))/n)
-          yield line.chomp("\n") + "\r\n"
-        end
-      end
-    end
-
-    def buffer_filling(buf, src)
-      case src
-      when String    # for speeding up.
-        0.step(src.size - 1, 1024) do |i|
-          buf << src[i, 1024]
-          yield
-        end
-      when File    # for speeding up.
-        while s = src.read(1024)
-          buf << s
-          yield
-        end
-      else    # generic reader
-        src.each do |s|
-          buf << s
-          yield if buf.size > 1024
-        end
-        yield unless buf.empty?
-      end
-    end
-  end
-
-
-  #
-  # The writer adapter class
-  #
-  class WriteAdapter
-    def initialize(socket, method)
-      @socket = socket
-      @method_id = method
-    end
-
-    def inspect
-      "#<#{self.class} socket=#{@socket.inspect}>"
-    end
-
-    def write(str)
-      @socket.__send__(@method_id, str)
-    end
-
-    alias print write
-
-    def <<(str)
-      write str
-      self
-    end
-
-    def puts(str = '')
-      write str.chomp("\n") + "\n"
-    end
-
-    def printf(*args)
-      write sprintf(*args)
-    end
-  end
-
-
-  class ReadAdapter   #:nodoc: internal use only
-    def initialize(block)
-      @block = block
-    end
-
-    def inspect
-      "#<#{self.class}>"
-    end
-
-    def <<(str)
-      call_block(str, &@block) if @block
-    end
-
-    private
-
-    # This method is needed because @block must be called by yield,
-    # not Proc#call.  You can see difference when using `break' in
-    # the block.
-    def call_block(str)
-      yield str
-    end
-  end
-
-
-  module NetPrivate   #:nodoc: obsolete
-    Socket = ::Net::InternetMessageIO
-  end
-
-end   # module Net