Ruby

# {'q' => 'ruby', 'max' => '50'})

# puts res.body

#

# 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

#

# uri = URI.parse('http://www.example.com/todo.cgi')

# req = Net::HTTP::Post.new(uri.path)

# req.basic_auth 'jack', 'pass'

#

# === Accessing via Proxy

#

#

# require 'net/http'

#

# :

# }

#

#

#

# Net::HTTP::Proxy(proxy_addr, proxy_port, proxy_user = nil, proxy_pass = nil)

#

#

# require 'net/http'

# require 'uri'

# }

#

# Note that net/http does not use the HTTP_PROXY environment variable.

#

# === Following Redirection

#

# print fetch('http://www.ruby-lang.org')

#

# Net::HTTPSuccess and Net::HTTPRedirection are HTTPResponse subclasses.

#

# === HTTP Request Classes

#

# Here is HTTP request class hierarchy.

#

# === HTTP Response Classes

#

#

#

# == 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.

#

#

# require 'net/http'

# Net::HTTP.version_1_2

@newimpl = false

end

# Defaults to true.

def HTTP.version_1_2?

@newimpl

end

# Defaults to true.

def HTTP.version_1_1?

not @newimpl

#

#

#

# Net::HTTP.get_print URI.parse('http://www.example.com/index.html')

#

nil

end

# 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

# as a Net::HTTPResponse object. The target can either be specified as

# (+uri+), or as (+host+, +path+, +port+ = 80); so:

#

end

end

#

# { "cmd" => "search", "q" => "ruby", "max" => "50" }

#

#

# 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)

#

#

# 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

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

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

def initialize(address, port = nil)

@address = address

@port = (port || HTTP.default_port)

"#<#{self.class} #{@address}:#{@port} open=#{started?}>"

end

# Never use this method in production code.

#

#

# http = Net::HTTP.new

# http.set_debug_output $stderr

@debug_output = output

end

attr_reader :address

# The port number to connect to.

attr_reader :port

# If the HTTP object cannot open a connection in this many seconds,

# it raises a TimeoutError exception.

attr_accessor :open_timeout

# it raises a TimeoutError exception.

attr_reader :read_timeout

@read_timeout = sec

end

def started?

@started

end

attr_accessor :close_on_empty_response

def use_ssl?

@use_ssl

end

@socket.io.peer_cert

end

#

#

def start # :yield: http

raise IOError, 'HTTP session already opened' if @started

if block_given?

end

private :on_connect

def finish

raise IOError, 'HTTP session not yet started' unless started?

do_finish

@proxy_user = nil

@proxy_pass = nil

#

#

# # 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

#

#

# # 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

# 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

# the socket. Note that in this case, the returned response

# object will *not* contain a (meaningful) body.

#

request(Trace.new(path, initheader))

end

#

# if desired.

#

# Returns the response.

# This method never raises Net::* exceptions.

#

# response = http.request_get('/index.html')

# p response['content-type']

# puts response.body

#

# 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

#

# Returns the response.

#

request(Head.new(path, initheader), &block)

end

#

#

# Returns the response.

#

# # example

# response = http.request_post('/cgi-bin/nice.rb', 'datadatadata...')

# p response.status

#

# # using block

# http.request_post('/cgi-bin/nice.rb', 'datadatadata...') {|response|

# Sends an HTTP request to the HTTP server.

#

#

# This method never raises Net::* exceptions.

#

request r, data

end

#

# if desired.

# This method never raises Net::* exceptions.

#

def request(req, body = nil, &block) # :yield: +response+

HTTPSession = HTTP

#

#

module HTTPHeader

def initialize_http_header(initheader)

end

# [Ruby 1.8.3]

# 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

# 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

def each_header #:yield: +key+, +value+

block_given? or return enum_for(__method__)

@header.each do |k,va|

alias each each_header

def each_name(&block) #:yield: +key+

block_given? or return enum_for(__method__)

@header.each_key(&block)

alias each_key each_name

def each_capitalized_name #:yield: +key+

block_given? or return enum_for(__method__)

@header.each_key do |k|

end

end

def each_value #:yield: +value+

block_given? or return enum_for(__method__)

@header.each_value do |va|

end

end

def delete(key)

@header.delete(key.downcase)

end

@header.key?(key.downcase)

end

def to_hash

@header.dup

end

# As for #each_header, except the keys are provided in capitalized form.

def each_capitalized

block_given? or return enum_for(__method__)

@header.each do |k,v|

end

private :capitalize

def range

return nil unless @header['range']

self['Range'].split(/,/).map {|spec|

}

end

#

# req.range = (0..1023)

# req.set_range 0, 1023

alias range= set_range

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

# fits inside the full entity body, as range of byte offsets.

def content_range

return nil unless @header['content-range']

sub.strip

end

def type_params

result = {}

list = self['Content-Type'].to_s.split(';')

result

end

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.

#

#

# Example:

# http.form_data = {"q" => "ruby", "lang" => "en"}

end

#

#

class HTTPGenericRequest

include HTTPHeader

#

#

class HTTPRequest < HTTPGenericRequest

# HTTP/1.1 methods --- RFC2616

#

class Get < HTTPRequest

METHOD = 'GET'

REQUEST_HAS_BODY = false

RESPONSE_HAS_BODY = true

end

class Head < HTTPRequest

METHOD = 'HEAD'

REQUEST_HAS_BODY = false

RESPONSE_HAS_BODY = false

end

class Post < HTTPRequest

METHOD = 'POST'

REQUEST_HAS_BODY = true

RESPONSE_HAS_BODY = true

end

class Put < HTTPRequest

METHOD = 'PUT'

REQUEST_HAS_BODY = true

RESPONSE_HAS_BODY = true

end

class Delete < HTTPRequest

METHOD = 'DELETE'

REQUEST_HAS_BODY = false

RESPONSE_HAS_BODY = true

end

class Options < HTTPRequest

METHOD = 'OPTIONS'

REQUEST_HAS_BODY = false

RESPONSE_HAS_BODY = false

end

class Trace < HTTPRequest

METHOD = 'TRACE'

REQUEST_HAS_BODY = false

#

# PATCH method --- RFC5789

#

class Patch < HTTPRequest

METHOD = 'PATCH'

REQUEST_HAS_BODY = true

# WebDAV methods --- RFC2518

#

class Propfind < HTTPRequest

METHOD = 'PROPFIND'

REQUEST_HAS_BODY = true

RESPONSE_HAS_BODY = true

end

class Proppatch < HTTPRequest

METHOD = 'PROPPATCH'

REQUEST_HAS_BODY = true

RESPONSE_HAS_BODY = true

end

class Mkcol < HTTPRequest

METHOD = 'MKCOL'

REQUEST_HAS_BODY = true

RESPONSE_HAS_BODY = true

end

class Copy < HTTPRequest

METHOD = 'COPY'

REQUEST_HAS_BODY = false

RESPONSE_HAS_BODY = true

end

class Move < HTTPRequest

METHOD = 'MOVE'

REQUEST_HAS_BODY = false

RESPONSE_HAS_BODY = true

end

class Lock < HTTPRequest

METHOD = 'LOCK'

REQUEST_HAS_BODY = true

RESPONSE_HAS_BODY = true

end

class Unlock < HTTPRequest

METHOD = 'UNLOCK'

REQUEST_HAS_BODY = true

###

# HTTP exception class.

module HTTPExceptions

def initialize(msg, res) #:nodoc:

super msg

end

# 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

attr_reader :code

attr_reader :message

alias msg message # :nodoc: obsolete

self.class::EXCEPTION_TYPE

end

def value

error! unless self.kind_of?(HTTPSuccess)

end

end

end

#

#

# http.request_get('/index.html') {|res|

# puts res.read_body

# }

@body

end

#

# Calling this method a second or subsequent time will return the

#

# http.request_get('/index.html') {|res|

# puts res.body