net/http: Ruby Standard Library Documentation

CEXCEPTION_TYPE

CEXCEPTION_TYPE

CEXCEPTION_TYPE

CEXCEPTION_TYPE

CHTTPMovedTemporarily

CHTTPMultipleChoice

CHTTPRequestURITooLarge

MNet

CNet::HTTP

CNet::HTTP::Copy

CNet::HTTP::Delete

CNet::HTTP::Get

CNet::HTTP::Head

CNet::HTTP::Lock

CNet::HTTP::Mkcol

CNet::HTTP::Move

CNet::HTTP::Options

CNet::HTTP::Patch

CNet::HTTP::Post

CNet::HTTP::Propfind

CNet::HTTP::Proppatch

CNet::HTTP::Put

CNet::HTTP::Trace

CNet::HTTP::Unlock

CNet::HTTPAccepted

CNet::HTTPAlreadyReported

CNet::HTTPBadGateway

CNet::HTTPBadRequest

CNet::HTTPBadResponse

CNet::HTTPClientError

CNet::HTTPConflict

CNet::HTTPContinue

CNet::HTTPCreated

CNet::HTTPError → Net::HTTPError

MNet::HTTPExceptions

CNet::HTTPExpectationFailed

CNet::HTTPFailedDependency

CNet::HTTPFatalError

CNet::HTTPForbidden

CNet::HTTPFound → Net::HTTPFound

CNet::HTTPGatewayTimeOut

CNet::HTTPGenericRequest

CNet::HTTPGone

MNet::HTTPHeader

CNet::HTTPHeaderSyntaxError

CNet::HTTPIMUsed

CNet::HTTPInformation

CNet::HTTPInsufficientStorage

CNet::HTTPInternalServerError

CNet::HTTPLengthRequired

CNet::HTTPLocked

CNet::HTTPLoopDetected

CNet::HTTPMethodNotAllowed

CNet::HTTPMisdirectedRequest

CNet::HTTPMovedPermanently

CNet::HTTPMultiStatus

CNet::HTTPMultipleChoices → Net::HTTPMultipleChoices

CNet::HTTPNetworkAuthenticationRequired

CNet::HTTPNoContent

CNet::HTTPNonAuthoritativeInformation

CNet::HTTPNotAcceptable

CNet::HTTPNotExtended

CNet::HTTPNotFound

CNet::HTTPNotImplemented

CNet::HTTPNotModified

CNet::HTTPOK

CNet::HTTPPartialContent

CNet::HTTPPaymentRequired

CNet::HTTPPermanentRedirect

CNet::HTTPPreconditionFailed

CNet::HTTPPreconditionRequired

CNet::HTTPProcessing

CNet::HTTPProxyAuthenticationRequired

CNet::HTTPRedirection

CNet::HTTPRequest

CNet::HTTPRequestEntityTooLarge

CNet::HTTPRequestHeaderFieldsTooLarge

CNet::HTTPRequestTimeOut

CNet::HTTPRequestURITooLong → Net::HTTPRequestURITooLong

CNet::HTTPRequestedRangeNotSatisfiable

CNet::HTTPResetContent

CNet::HTTPResponse

CNet::HTTPRetriableError → Net::HTTPRetriableError

CNet::HTTPSeeOther

CNet::HTTPServerError

CNet::HTTPServerException

CNet::HTTPServiceUnavailable

CNet::HTTPSuccess

CNet::HTTPSwitchProtocol

CNet::HTTPTemporaryRedirect

CNet::HTTPTooManyRequests

CNet::HTTPUnauthorized

CNet::HTTPUnavailableForLegalReasons

CNet::HTTPUnknownResponse

CNet::HTTPUnprocessableEntity

CNet::HTTPUnsupportedMediaType

CNet::HTTPUpgradeRequired

CNet::HTTPUseProxy

CNet::HTTPVariantAlsoNegotiates

CNet::HTTPVersionNotSupported

::Proxy (Net::HTTP)

::body_permitted? (Net::HTTPResponse)

::default_port (Net::HTTP)

::get (Net::HTTP)

::get_print (Net::HTTP)

::get_response (Net::HTTP)

::http_default_port (Net::HTTP)

::https_default_port (Net::HTTP)

::is_version_1_2? (Net::HTTP)

::new (Net::HTTP)

::new (Net::HTTP)

::new (Net::HTTPGenericRequest)

::new (Net::HTTPRequest)

::newobj (Net::HTTP)

::post (Net::HTTP)

::post_form (Net::HTTP)

::proxy_class? (Net::HTTP)

::start (Net::HTTP)

::version_1_2 (Net::HTTP)

::version_1_2? (Net::HTTP)

#[] (Net::HTTPHeader)

#[]= (Net::HTTPHeader)

#active? (Net::HTTP)

#add_field (Net::HTTPHeader)

#basic_auth (Net::HTTPHeader)

#body (Net::HTTPResponse)

#body= (Net::HTTPGenericRequest)

#body= (Net::HTTPResponse)

#body_exist? (Net::HTTPGenericRequest)

#body_stream= (Net::HTTPGenericRequest)

#canonical_each (Net::HTTPHeader)

#chunked? (Net::HTTPHeader)

#connection_close? (Net::HTTPHeader)

#connection_keep_alive? (Net::HTTPHeader)

#content_length (Net::HTTPHeader)

#content_length= (Net::HTTPHeader)

#content_range (Net::HTTPHeader)

#content_type (Net::HTTPHeader)

#content_type= (Net::HTTPHeader)

#continue_timeout= (Net::HTTP)

#copy (Net::HTTP)

#delete (Net::HTTP)

#delete (Net::HTTPHeader)

#each (Net::HTTPHeader)

#each_capitalized (Net::HTTPHeader)

#each_capitalized_name (Net::HTTPHeader)

#each_header (Net::HTTPHeader)

#each_key (Net::HTTPHeader)

#each_name (Net::HTTPHeader)

#each_value (Net::HTTPHeader)

#entity (Net::HTTPResponse)

#fetch (Net::HTTPHeader)

#finish (Net::HTTP)

#form_data= (Net::HTTPHeader)

#get (Net::HTTP)

#get2 (Net::HTTP)

#get_fields (Net::HTTPHeader)

#head (Net::HTTP)

#head2 (Net::HTTP)

#initialize_http_header (Net::HTTPHeader)

#inspect (Net::HTTP)

#inspect (Net::HTTPGenericRequest)

#inspect (Net::HTTPResponse)

#key? (Net::HTTPHeader)

#lock (Net::HTTP)

#main_type (Net::HTTPHeader)

#max_retries= (Net::HTTP)

#mkcol (Net::HTTP)

#move (Net::HTTP)

#options (Net::HTTP)

#patch (Net::HTTP)

#peer_cert (Net::HTTP)

#post (Net::HTTP)

#post2 (Net::HTTP)

#propfind (Net::HTTP)

#proppatch (Net::HTTP)

#proxy? (Net::HTTP)

#proxy_address (Net::HTTP)

#proxy_basic_auth (Net::HTTPHeader)

#proxy_from_env? (Net::HTTP)

#proxy_pass (Net::HTTP)

#proxy_port (Net::HTTP)

#proxy_user (Net::HTTP)

#proxyaddr (Net::HTTP)

#proxyport (Net::HTTP)

#range (Net::HTTPHeader)

#range= (Net::HTTPHeader)

#range_length (Net::HTTPHeader)

#read_body (Net::HTTPResponse)

#read_timeout= (Net::HTTP)

#request (Net::HTTP)

#request_body_permitted? (Net::HTTPGenericRequest)

#request_get (Net::HTTP)

#request_head (Net::HTTP)

#request_post (Net::HTTP)

#response_body_permitted? (Net::HTTPGenericRequest)

#send_request (Net::HTTP)

#set_content_type (Net::HTTPHeader)

#set_debug_output (Net::HTTP)

#set_form (Net::HTTPHeader)

#set_form_data (Net::HTTPHeader)

#set_range (Net::HTTPHeader)

#start (Net::HTTP)

#started? (Net::HTTP)

#sub_type (Net::HTTPHeader)

#to_hash (Net::HTTPHeader)

#trace (Net::HTTP)

#type_params (Net::HTTPHeader)

#unlock (Net::HTTP)

#use_ssl= (Net::HTTP)

#use_ssl? (Net::HTTP)

#value (Net::HTTPResponse)