Project

General

Profile

Feature #4100 » net-http-2010.patch

Patches against 1.9 HEAD to improve net/http documentation - meta (mathew murphy), 11/30/2010 08:26 AM

View differences:

http.rb (working copy)
# {'q' => 'ruby', 'max' => '50'})
# puts res.body
#
# #2: POST with basic authentication
# #2: POST with basic authentication supplied in the URL
#
# (Note that this is not a legal URL as per RFC 1738 section 3.3, but
# is supported by post_form for historical reasons.)
#
# res = Net::HTTP.post_form(URI.parse('http://jack:pass@www.example.com/todo.cgi'),
# {'from' => '2005-01-01',
# 'to' => '2005-03-31'})
# puts res.body
#
# #3: Detailed control
# #3: Detailed control of POST with authentication
#
# uri = URI.parse('http://www.example.com/todo.cgi')
# req = Net::HTTP::Post.new(uri.path)
# req.basic_auth 'jack', 'pass'
......
#
# === Accessing via Proxy
#
# Net::HTTP::Proxy has the same methods as Net::HTTP but its instances always
# connect via the proxy, instead of given host.
# Net::HTTP.Proxy is an http proxy class. It has the same
# methods as Net::HTTP, but its instances always connect via a proxy,
# instead of directly to the given host.
#
# require 'net/http'
#
......
# :
# }
#
# Since Net::HTTP::Proxy returns Net::HTTP itself when proxy_addr is nil,
# there's no need to change code if there's a proxy or not.
# The top-level Net::HTTP class creates objects which represent
# HTTP sessions.
#
# There are two additional parameters in Net::HTTP::Proxy which you can use to
# specify a proxy username and password:
# Since Net::HTTP.Proxy returns Net::HTTP itself when +proxy_addr+ is nil,
# there's no need to change your code depending on whether there's a proxy
# or not.
#
# There are two additional parameters in Net::HTTP.Proxy which allow you to
# specify a user name and password for the proxy:
#
# Net::HTTP::Proxy(proxy_addr, proxy_port, proxy_user = nil, proxy_pass = nil)
#
# You may use them to work with authorization-enabled proxies:
# You can use them to work with authorization-enabled proxies:
#
# require 'net/http'
# require 'uri'
......
# }
#
# Note that net/http does not use the HTTP_PROXY environment variable.
# If you want to use a proxy, you must set it explicitly.
# If you want to use a proxy, you must do so explicitly.
#
# === Following Redirection
#
......
# print fetch('http://www.ruby-lang.org')
#
# Net::HTTPSuccess and Net::HTTPRedirection are HTTPResponse subclasses.
# All HTTPResponse objects belong to their own response class which
# indicates the HTTP result status.
# All HTTPResponse objects belong to their own response class, which
# indicates the HTTP result status. For details of the response classes,
# see the section "HTTP Response Classes".
#
# === Full example with retrying and error reporting
#
# require 'uri'
# require 'net/http'
#
# url = "http://www.example.com/"
#
# # Break apart the URL
# uri = URI.parse(url)
# # Reassemble the path for the HTTP request
# if uri.query
# path = uri.path + '?' + uri.query
# else
# path = uri.path
# end
#
# # Create a request object
# request = Net::HTTP::Get.new(path)
#
# # Prepare an HTTP connection object
# http = Net::HTTP.new(uri.host, uri.port)
#
# # Open the connection and issue the request, retrying up to 3 times if there
# # is a timeout
# attempts = 1
# begin
# response = http.request(request)
# rescue Exception => e
# puts e
# puts "[Retrying]"
# attempts += 1
# retry if attempts <= 3
# end
#
# # Report the result
# if response.kind_of? Net::HTTPSuccess
# puts response.body
# else
# raise "Error fetching #{url}: #{response.code} #{response.message}"
# end
#
# === HTTP Request Classes
#
# Here is HTTP request class hierarchy.
......
#
# === HTTP Response Classes
#
# Here is HTTP response class hierarchy.
# All classes are defined in Net module.
# The request() method returns a response of a specific class, depending
# on the result of the HTTP request.
#
# HTTPResponse
# HTTPUnknownResponse
# HTTPInformation # 1xx
# HTTPContinue # 100
# HTTPSwitchProtocol # 101
# HTTPSuccess # 2xx
# HTTPOK # 200
# HTTPCreated # 201
# HTTPAccepted # 202
# HTTPNonAuthoritativeInformation # 203
# HTTPNoContent # 204
# HTTPResetContent # 205
# HTTPPartialContent # 206
# HTTPRedirection # 3xx
# HTTPMultipleChoice # 300
# HTTPMovedPermanently # 301
# HTTPFound # 302
# HTTPSeeOther # 303
# HTTPNotModified # 304
# HTTPUseProxy # 305
# HTTPTemporaryRedirect # 307
# HTTPClientError # 4xx
# HTTPBadRequest # 400
# HTTPUnauthorized # 401
# HTTPPaymentRequired # 402
# HTTPForbidden # 403
# HTTPNotFound # 404
# HTTPMethodNotAllowed # 405
# HTTPNotAcceptable # 406
# HTTPProxyAuthenticationRequired # 407
# HTTPRequestTimeOut # 408
# HTTPConflict # 409
# HTTPGone # 410
# HTTPLengthRequired # 411
# HTTPPreconditionFailed # 412
# HTTPRequestEntityTooLarge # 413
# HTTPRequestURITooLong # 414
# HTTPUnsupportedMediaType # 415
# HTTPRequestedRangeNotSatisfiable # 416
# HTTPExpectationFailed # 417
# HTTPServerError # 5xx
# HTTPInternalServerError # 500
# HTTPNotImplemented # 501
# HTTPBadGateway # 502
# HTTPServiceUnavailable # 503
# HTTPGatewayTimeOut # 504
# HTTPVersionNotSupported # 505
# To check the result, you can use the kind_of? method. Example:
#
# response = http.request(req)
# case
# when response.kind_of? Net::HTTPSuccess
# # Succeeded
# when response.kind_of? Net::HTTPRedirection
# # Page has moved, handle redirect
# when response.kind_of? Net::HTTPServerError
# # Site is broken
# end
#
# See Net::HTTPResponse for the complete hierarchy of response classes.
#
# The HTTPResponse classes all provide +code+ and +message+ accessors to
# obtain the 3-digit HTTP result code and the HTTP result message sent by
# the server.
#
# == Switching Net::HTTP versions
#
# You can use net/http.rb 1.1 features (bundled with Ruby 1.6)
......
# Turns on net/http 1.2 (ruby 1.8) features.
# Defaults to ON in ruby 1.8.
#
# I strongly recommend to call this method always.
# It is strongly recommend that you call this method always, unless
# you have a specific reason for needing only HTTP 1.1.
#
# require 'net/http'
# Net::HTTP.version_1_2
......
@newimpl = false
end
# true if net/http is in version 1.2 mode.
# Returns true if net/http is in version 1.2 mode.
# Defaults to true.
def HTTP.version_1_2?
@newimpl
end
# true if net/http is in version 1.1 compatible mode.
! # Returns true if net/http is in version 1.1 compatible mode.
# Defaults to true.
def HTTP.version_1_1?
not @newimpl
......
#
#
# Get body from target and output it to +$stdout+. The
# target can either be specified as (+uri+), or as
# (+host+, +path+, +port+ = 80); so:
# Gets the body text from the target and outputs it to $stdout. The
# target can either be specified as a URI object, or as
# (host, path, port = 80); so:
#
# Net::HTTP.get_print URI.parse('http://www.example.com/index.html')
#
......
nil
end
# Send a GET request to the target and return the response
# Sends a GET request to the target and returns the HTTP response
# as a string. The target can either be specified as
# (+uri+), or as (+host+, +path+, +port+ = 80); so:
#
......
get_response(uri_or_host, path, port).body
end
# Send a GET request to the target and return the response
# Sends a GET request to the target and returns the HTTP response
# as a Net::HTTPResponse object. The target can either be specified as
# (+uri+), or as (+host+, +path+, +port+ = 80); so:
#
......
end
end
# Posts HTML form data to the +URL+.
# Form data must be represented as a Hash of String to String, e.g:
# Posts HTML form data to the specified URI object.
# The form data must be provided as a Hash mapping from String to String.
# Example:
#
# { "cmd" => "search", "q" => "ruby", "max" => "50" }
#
# This method also does Basic Authentication iff +URL+.user exists.
# This method also does Basic Authentication iff +URI+.user exists.
#
# Example:
#
......
# HTTP.start(address, port, p_addr, p_port, p_user, p_pass, &block)
# HTTP.start(address, port=nil, p_addr=nil, p_port=nil, p_user=nil, p_pass=nil, opt, &block)
#
# creates a new Net::HTTP object and opens its TCP connection and
# HTTP session.
# Creates a new Net::HTTP object, then additionally opens the TCP
# connection and HTTP session.
#
# Argments are following:
# _address_ :: hostname or IP address of the server
......
# block finishes. In this case, the return value of this method
# is the return value of the block. If no block is given, the
# return value of this method is the newly created Net::HTTP object
# itself, and the caller is responsible for closing it upon completion.
# itself, and the caller is responsible for closing it upon completion
# using the finish() method.
def HTTP.start(address, *arg, &block) # :yield: +http+
arg.pop if opt = Hash.try_convert(arg[-1])
port, p_addr, p_port, p_user, p_pass = *arg
......
alias newobj new
end
# Creates a new Net::HTTP object.
# If +proxy_addr+ is given, creates an Net::HTTP object with proxy support.
# This method does not open the TCP connection.
# Creates a new Net::HTTP object without opening a TCP connection or
# HTTP session.
# The +address+ should be a DNS hostname or IP address.
# If +p_addr+ is given, creates a Net::HTTP object with proxy support.
def HTTP.new(address, port = nil, p_addr = nil, p_port = nil, p_user = nil, p_pass = nil)
h = Proxy(p_addr, p_port, p_user, p_pass).newobj(address, port)
h.instance_eval {
......
h
end
# Creates a new Net::HTTP object for the specified +address+.
# This method does not open the TCP connection.
# Creates a new Net::HTTP object for the specified server address,
# without opening the TCP connection or initializing the HTTP session.
# The +address+ should be a DNS hostname or IP address.
def initialize(address, port = nil)
@address = address
@port = (port || HTTP.default_port)
......
"#<#{self.class} #{@address}:#{@port} open=#{started?}>"
end
# *WARNING* This method causes serious security hole.
# *WARNING* This method opens a serious security hole.
# Never use this method in production code.
#
# Set an output stream for debugging.
# Sets an output stream for debugging.
#
# http = Net::HTTP.new
# http.set_debug_output $stderr
......
@debug_output = output
end
# The host name to connect to.
# The DNS host name or IP address to connect to.
attr_reader :address
# The port number to connect to.
attr_reader :port
# Seconds to wait until connection is opened.
# Number of seconds to wait for the connection to open.
# If the HTTP object cannot open a connection in this many seconds,
# it raises a TimeoutError exception.
attr_accessor :open_timeout
# Seconds to wait until reading one block (by one read(2) call).
# If the HTTP object cannot open a connection in this many seconds,
# Number of seconds to wait for one block to be read (via one read(2)
# call). If the HTTP object cannot read data in this many seconds,
# it raises a TimeoutError exception.
attr_reader :read_timeout
......
@read_timeout = sec
end
# returns true if the HTTP session is started.
# Returns true if the HTTP session has been started.
def started?
@started
end
......
attr_accessor :close_on_empty_response
# returns true if use SSL/TLS with HTTP.
# Returns true if SSL/TLS is being used with HTTP.
def use_ssl?
@use_ssl
end
......
@socket.io.peer_cert
end
# Opens TCP connection and HTTP session.
# Opens a TCP connection and HTTP session.
#
# When this method is called with a block, it passes the Net::HTTP
# object to the block, and closes the TCP connection and HTTP session
# after the block has been executed.
#
# When this method is called with block, gives a HTTP object
# to the block and closes the TCP connection / HTTP session
# after the block executed.
# When called with a block, it returns the return value of the
# block; otherwise, it returns self.
#
# When called with a block, returns the return value of the
# block; otherwise, returns self.
#
def start # :yield: http
raise IOError, 'HTTP session already opened' if @started
if block_given?
......
end
private :on_connect
# Finishes HTTP session and closes TCP connection.
# Raises IOError if not started.
# Finishes the HTTP session and closes the TCP connection.
# Raises IOError if the session has not been started.
def finish
raise IOError, 'HTTP session not yet started' unless started?
do_finish
......
@proxy_user = nil
@proxy_pass = nil
# Creates an HTTP proxy class.
# Arguments are address/port of proxy host and username/password
# if authorization on proxy server is required.
# You can replace the HTTP class with created proxy class.
# Creates an HTTP proxy class which behaves like Net::HTTP, but
# performs all access via the specified proxy.
#
# If ADDRESS is nil, this method returns self (Net::HTTP).
# The arguments are the DNS name or IP address of the proxy host,
# the port to use to access the proxy, and a username and password
# if authorization is required to use the proxy.
#
# You can replace any use of the Net::HTTP class with use of the
# proxy class created.
#
# If +p_addr+ is nil, this method returns self (a Net::HTTP object).
#
# # Example
# proxy_class = Net::HTTP::Proxy('proxy.example.com', 8080)
# :
......
#
# In version 1.1, this method might raise an exception for
# 3xx (redirect). In this case you can get a HTTPResponse object
# by "anException.response".
# from "anException.response".
#
# In version 1.2, this method never raises exception.
# In version 1.2, this method never raises an exception.
#
# # version 1.1 (bundled with Ruby 1.6)
# response, body = http.get('/index.html')
......
#
# In version 1.1, this method might raise an exception for
# 3xx (redirect). On the case you can get a HTTPResponse object
# by "anException.response".
# as "anException.response".
#
# In version 1.2, this method never raises an exception.
#
# response = nil
......
# In version 1.2 (ruby 1.8), this method returns a Net::HTTPResponse object.
#
# If called with a block, yields each fragment of the
# entity body in turn as a string as it are read from
# entity body in turn as a string as it is read from
# the socket. Note that in this case, the returned response
# object will *not* contain a (meaningful) body.
#
......
request(Trace.new(path, initheader))
end
# Sends a GET request to the +path+ and gets a response,
# as an HTTPResponse object.
# Sends a GET request to the +path+.
# Returns the response as a Net::HTTPResponse object.
#
# When called with a block, yields an HTTPResponse object.
# The body of this response will not have been read yet;
# the caller can process it using HTTPResponse#read_body,
# When called with a block, passes an HTTPResponse object to the block.
# The body of the response will not have been read yet;
# the block can process it using HTTPResponse#read_body,
# if desired.
#
# Returns the response.
......
# This method never raises Net::* exceptions.
#
# response = http.request_get('/index.html')
# # The entity body is already read here.
# # The entity body is already read in this case.
# p response['content-type']
# puts response.body
#
# # using block
# # Using a block
# http.request_get('/index.html') {|response|
# p response['content-type']
# response.read_body do |str| # read body now
......
request(Get.new(path, initheader), &block)
end
# Sends a HEAD request to the +path+ and gets a response,
# as an HTTPResponse object.
# Sends a HEAD request to the +path+ and returns the response
# as a Net::HTTPResponse object.
#
# Returns the response.
#
......
request(Head.new(path, initheader), &block)
end
# Sends a POST request to the +path+ and gets a response,
# as an HTTPResponse object.
# Sends a POST request to the +path+.
#
# When called with a block, yields an HTTPResponse object.
# The body of this response will not have been read yet;
# the caller can process it using HTTPResponse#read_body,
# if desired.
# Returns the response as a Net::HTTPResponse object.
#
# When called with a block, the block is passed an HTTPResponse
# object. The body of that response will not have been read yet;
# the block can process it using HTTPResponse#read_body, if desired.
#
# Returns the response.
#
......
# # example
# response = http.request_post('/cgi-bin/nice.rb', 'datadatadata...')
# p response.status
# puts response.body # body is already read
# puts response.body # body is already read in this case
#
# # using block
# http.request_post('/cgi-bin/nice.rb', 'datadatadata...') {|response|
......
# Sends an HTTP request to the HTTP server.
# This method also sends DATA string if DATA is given.
# Also sends a DATA string if +data+ is given.
#
# Returns a HTTPResponse object.
# Returns a Net::HTTPResponse object.
#
# This method never raises Net::* exceptions.
#
......
request r, data
end
# Sends an HTTPRequest object REQUEST to the HTTP server.
# This method also sends DATA string if REQUEST is a post/put request.
# Giving DATA for get/head request causes ArgumentError.
# Sends an HTTPRequest object +req+ to the HTTP server.
#
# When called with a block, yields an HTTPResponse object.
# The body of this response will not have been read yet;
# the caller can process it using HTTPResponse#read_body,
# If +req+ is a Net::HTTP::Post or Net::HTTP::Put request containing
# data, the data is also sent. Providing data for a Net::HTTP::Head or
# Net::HTTP::Get request results in an ArgumentError.
#
# Returns an HTTPResponse object.
#
# When called with a block, passes an HTTPResponse object to the block.
# The body of the response will not have been read yet;
# the block can process it using HTTPResponse#read_body,
# if desired.
#
# Returns a HTTPResponse object.
#
#
# This method never raises Net::* exceptions.
#
def request(req, body = nil, &block) # :yield: +response+
......
HTTPSession = HTTP
# The HTTPHeader module defines methods for reading and writing
# HTTP headers.
#
# Header module.
# It is used as a mixin by other classes, to provide hash-like
# access to HTTP header values. Unlike raw hash access, HTTPHeader
# provides access via case-insensitive keys. It also provides
# methods for accessing commonly-used HTTP header values in more
# convenient formats.
#
# Provides access to @header in the mixed-into class as a hash-like
# object, except with case-insensitive keys. Also provides
# methods for accessing commonly-used header values in a more
# convenient format.
#
module HTTPHeader
def initialize_http_header(initheader)
......
end
# [Ruby 1.8.3]
# Adds header field instead of replace.
# Adds a value to a named header field, instead of replacing its value.
# Second argument +val+ must be a String.
# See also #[]=, #[] and #get_fields.
#
......
# Returns the header field corresponding to the case-insensitive key.
# Returns the default value +args+, or the result of the block, or
# raises an IndexErrror if there's no header field named +key+
# raises an IndexError if there's no header field named +key+
# See Hash#fetch
def fetch(key, *args, &block) #:yield: +key+
a = @header.fetch(key.downcase, *args, &block)
a.kind_of?(Array) ? a.join(', ') : a
end
# Iterates for each header names and values.
# Iterates through the header names and values, passing in the name
# and value to the code block supplied.
#
# Example:
#
# response.header.each_header {|key,value| puts "#{key} = #{value}" }
#
def each_header #:yield: +key+, +value+
block_given? or return enum_for(__method__)
@header.each do |k,va|
......
alias each each_header
# Iterates for each header names.
# Iterates through the header names in the header, passing
# each header name to the code block.
def each_name(&block) #:yield: +key+
block_given? or return enum_for(__method__)
@header.each_key(&block)
......
alias each_key each_name
# Iterates for each capitalized header names.
# Iterates through the header names in the header, passing
# capitalized header names to the code block.
#
# Note that header names are capitalized systematically;
# capitalization may not match that used by the remote HTTP
# server in its response.
def each_capitalized_name #:yield: +key+
block_given? or return enum_for(__method__)
@header.each_key do |k|
......
end
end
# Iterates for each header values.
# Iterates through header values, passing each value to the
# code block.
def each_value #:yield: +value+
block_given? or return enum_for(__method__)
@header.each_value do |va|
......
end
end
# Removes a header field.
# Removes a header field, specified by case-insensitive key.
def delete(key)
@header.delete(key.downcase)
end
......
@header.key?(key.downcase)
end
# Returns a Hash consist of header names and values.
# Returns a Hash consisting of header names and values.
# e.g.
# {"cache-control" => "private",
# "content-type" => "text/html",
# "date" => "Wed, 22 Jun 2005 22:11:50 GMT"}
def to_hash
@header.dup
end
# As for #each_header, except the keys are provided in capitalized form.
#
# Note that header names are capitalized systematically;
# capitalization may not match that used by the remote HTTP
# server in its response.
def each_capitalized
block_given? or return enum_for(__method__)
@header.each do |k,v|
......
end
private :capitalize
# Returns an Array of Range objects which represents Range: header field,
# or +nil+ if there is no such header.
# Returns an Array of Range objects which represent the Range:
# HTTP header field, or +nil+ if there is no such header.
def range
return nil unless @header['range']
self['Range'].split(/,/).map {|spec|
......
}
end
# Set Range: header from Range (arg r) or beginning index and
# length from it (arg idx&len).
# Sets the HTTP Range: header.
# Accepts either a Range object as a single argument,
# or a beginning index and a length from that index.
# Example:
#
# req.range = (0..1023)
# req.set_range 0, 1023
......
alias range= set_range
# Returns an Integer object which represents the Content-Length: header field
# or +nil+ if that field is not provided.
# Returns an Integer object which represents the HTTP Content-Length:
# header field, or +nil+ if that field was not provided.
def content_length
return nil unless key?('Content-Length')
len = self['Content-Length'].slice(/\d+/) or
......
(/(?:\A|[^\-\w])chunked(?![\-\w])/i =~ field) ? true : false
end
# Returns a Range object which represents Content-Range: header field.
# This indicates, for a partial entity body, where this fragment
# Returns a Range object which represents the value of the Content-Range:
# header field.
# For a partial entity body, this indicates where this fragment
# fits inside the full entity body, as range of byte offsets.
def content_range
return nil unless @header['content-range']
......
sub.strip
end
# Returns content type parameters as a Hash as like
# {"charset" => "iso-2022-jp"}.
# Any parameters specified for the content type, returned as a Hash.
# For example, a header of Content-Type: text/html; charset=EUC-JP
# would result in type_params returning {'charset' => 'EUC-JP'}
def type_params
result = {}
list = self['Content-Type'].to_s.split(';')
......
result
end
# Set Content-Type: header field by +type+ and +params+.
# +type+ must be a String, +params+ must be a Hash.
# Sets the content type in an HTTP header.
# The +type+ should be a full HTTP content type, e.g. "text/html".
# The +params+ are an optional Hash of parameters to add after the
# content type, e.g. {'charset' => 'iso-8859-1'}
def set_content_type(type, params = {})
@header['content-type'] = [type + params.map{|k,v|"; #{k}=#{v}"}.join('')]
end
......
# +params+ should be a Hash containing HTML form data.
# Optional argument +sep+ means data record separator.
#
# This method also set Content-Type: header field to
# application/x-www-form-urlencoded.
# Values are URL encoded as necessary and the content-type is set to
# application/x-www-form-urlencoded
#
# Example:
# http.form_data = {"q" => "ruby", "lang" => "en"}
......
end
# HTTPGenericRequest is the parent of the HTTPRequest class.
# Do not use this directly; use a subclass of HTTPRequest.
#
# Parent of HTTPRequest class. Do not use this directly; use
# a subclass of HTTPRequest.
# Mixes in the HTTPHeader module to provide easier access to HTTP headers.
#
# Mixes in the HTTPHeader module.
#
class HTTPGenericRequest
include HTTPHeader
......
#
# HTTP request class. This class wraps request header and entity path.
# You *must* use its subclass, Net::HTTP::Get, Post, Head.
# HTTP request class.
# This class wraps together the request header and the request path.
# You cannot use this class directly. Instead, you should use one of its
# subclasses: Net::HTTP::Get, Net::HTTP::Post, Net::HTTP::Head.
#
class HTTPRequest < HTTPGenericRequest
......
# HTTP/1.1 methods --- RFC2616
#
# See Net::HTTPGenericRequest for attributes and methods.
# See Net::HTTP for usage examples.
class Get < HTTPRequest
METHOD = 'GET'
REQUEST_HAS_BODY = false
RESPONSE_HAS_BODY = true
end
# See Net::HTTPGenericRequest for attributes and methods.
# See Net::HTTP for usage examples.
class Head < HTTPRequest
METHOD = 'HEAD'
REQUEST_HAS_BODY = false
RESPONSE_HAS_BODY = false
end
# See Net::HTTPGenericRequest for attributes and methods.
# See Net::HTTP for usage examples.
class Post < HTTPRequest
METHOD = 'POST'
REQUEST_HAS_BODY = true
RESPONSE_HAS_BODY = true
end
# See Net::HTTPGenericRequest for attributes and methods.
# See Net::HTTP for usage examples.
class Put < HTTPRequest
METHOD = 'PUT'
REQUEST_HAS_BODY = true
RESPONSE_HAS_BODY = true
end
# See Net::HTTPGenericRequest for attributes and methods.
# See Net::HTTP for usage examples.
class Delete < HTTPRequest
METHOD = 'DELETE'
REQUEST_HAS_BODY = false
RESPONSE_HAS_BODY = true
end
# See Net::HTTPGenericRequest for attributes and methods.
class Options < HTTPRequest
METHOD = 'OPTIONS'
REQUEST_HAS_BODY = false
RESPONSE_HAS_BODY = false
end
# See Net::HTTPGenericRequest for attributes and methods.
class Trace < HTTPRequest
METHOD = 'TRACE'
REQUEST_HAS_BODY = false
......
#
# PATCH method --- RFC5789
#
# See Net::HTTPGenericRequest for attributes and methods.
class Patch < HTTPRequest
METHOD = 'PATCH'
REQUEST_HAS_BODY = true
......
# WebDAV methods --- RFC2518
#
# See Net::HTTPGenericRequest for attributes and methods.
class Propfind < HTTPRequest
METHOD = 'PROPFIND'
REQUEST_HAS_BODY = true
RESPONSE_HAS_BODY = true
end
# See Net::HTTPGenericRequest for attributes and methods.
class Proppatch < HTTPRequest
METHOD = 'PROPPATCH'
REQUEST_HAS_BODY = true
RESPONSE_HAS_BODY = true
end
# See Net::HTTPGenericRequest for attributes and methods.
class Mkcol < HTTPRequest
METHOD = 'MKCOL'
REQUEST_HAS_BODY = true
RESPONSE_HAS_BODY = true
end
# See Net::HTTPGenericRequest for attributes and methods.
class Copy < HTTPRequest
METHOD = 'COPY'
REQUEST_HAS_BODY = false
RESPONSE_HAS_BODY = true
end
# See Net::HTTPGenericRequest for attributes and methods.
class Move < HTTPRequest
METHOD = 'MOVE'
REQUEST_HAS_BODY = false
RESPONSE_HAS_BODY = true
end
# See Net::HTTPGenericRequest for attributes and methods.
class Lock < HTTPRequest
METHOD = 'LOCK'
REQUEST_HAS_BODY = true
RESPONSE_HAS_BODY = true
end
# See Net::HTTPGenericRequest for attributes and methods.
class Unlock < HTTPRequest
METHOD = 'UNLOCK'
REQUEST_HAS_BODY = true
......
###
# HTTP exception class.
# You must use its subclasses.
# You cannot use HTTPExceptions directly; instead, you must use
# its subclasses.
module HTTPExceptions
def initialize(msg, res) #:nodoc:
super msg
......
end
# HTTP response class. This class wraps response header and entity.
# Mixes in the HTTPHeader module, which provides access to response
# header values both via hash-like methods and individual readers.
# HTTP response class.
#
# This class wraps together the response header and the response body (the
# entity requested).
#
# It mixes in the HTTPHeader module, which provides access to response
# header values both via hash-like methods and via individual readers.
#
# Note that each possible HTTP response code defines its own
# HTTPResponse subclass. These are listed below.
#
# All classes are
# defined under the Net module. Indentation indicates inheritance.
#
......
# The HTTP version supported by the server.
attr_reader :http_version
# HTTP result code string. For example, '302'. You can also
# determine the response type by which response subclass the
# response object is an instance of.
# The HTTP result code string. For example, '302'. You can also
# determine the response type by examining which response subclass
# the response object is an instance of.
attr_reader :code
# HTTP result message. For example, 'Not Found'.
# The HTTP result message sent by the server. For example, 'Not Found'.
attr_reader :message
alias msg message # :nodoc: obsolete
......
self.class::EXCEPTION_TYPE
end
# Raises HTTP error if the response is not 2xx.
# Raises an HTTP error if the response is not 2xx (success).
def value
error! unless self.kind_of?(HTTPSuccess)
end
......
end
end
# Gets entity body. If the block given, yields it to +block+.
# The body is provided in fragments, as it is read in from the socket.
# Gets the entity body returned by the remote HTTP server.
#
# Calling this method a second or subsequent time will return the
# already read string.
# If a block is given, the body is passed to the block, and
# the body is provided in fragments, as it is read in from the socket.
#
# Calling this method a second or subsequent time for the same
# HTTPResponse object will return the value already read.
#
# http.request_get('/index.html') {|res|
# puts res.read_body
# }
......
@body
end
# Returns the entity body.
# Returns the full entity body.
#
# Calling this method a second or subsequent time will return the
# already read string.
# string already read.
#
# http.request_get('/index.html') {|res|
# puts res.body
(2-2/3)