Module: HTTPotato::ClassMethods

Extended by:
AllowedFormatsDeprecation
Defined in:
lib/httpotato.rb

Instance Method Summary collapse

Methods included from AllowedFormatsDeprecation

const_missing

Instance Method Details

#base_uri(uri = nil) ⇒ Object

Allows setting a base uri to be used for each request. Will normalize uri to include http, etc.

class Foo
  include HTTPotato
  base_uri 'twitter.com'
end



63
64
65
66
 
# File 'lib/httpotato.rb', line 63

def base_uri(uri=nil)
  return default_options[:base_uri] unless uri
  default_options[:base_uri] = HTTPotato.normalize_base_uri(uri)
end

#basic_auth(u, p) ⇒ Object

Allows setting basic authentication username and password.

class Foo
  include HTTPotato
  basic_auth 'username', 'password'
end



74
75
76
 
# File 'lib/httpotato.rb', line 74

def basic_auth(u, p)
  default_options[:basic_auth] = {:username => u, :password => p}
end

#cookies(h = {}) ⇒ Object

Raises:

  • (ArgumentError) 


136
137
138
139
 
# File 'lib/httpotato.rb', line 136

def cookies(h={})
  raise ArgumentError, 'Cookies must be a hash' unless h.is_a?(Hash)
  default_cookies.add_cookies(h)
end

#debug_output(stream = $stderr) ⇒ Object

Set an output stream for debugging, defaults to $stderr. The output stream is passed on to Net::HTTP#set_debug_output.

class Foo
  include HTTPotato
  debug_output $stderr
end



120
121
122
 
# File 'lib/httpotato.rb', line 120

def debug_output(stream = $stderr)
  default_options[:debug_output] = stream
end

#default_options ⇒ Object

:nodoc:



293
294
295
 
# File 'lib/httpotato.rb', line 293

def default_options #:nodoc:
  @default_options
end

#default_params(h = {}) ⇒ Object

Allows setting default parameters to be appended to each request. Great for api keys and such.

class Foo
  include HTTPotato
  default_params :api_key => 'secret', :another => 'foo'
end

Raises:

  • (ArgumentError) 


95
96
97
98
99
 
# File 'lib/httpotato.rb', line 95

def default_params(h={})
  raise ArgumentError, 'Default params must be a hash' unless h.is_a?(Hash)
  default_options[:default_params] ||= {}
  default_options[:default_params].merge!(h)
end

#default_timeout(t) ⇒ Object

Allows setting a default timeout for all HTTP calls Timeout is specified in seconds.

class Foo
  include HTTPotato
  default_timeout 10
end

Raises:

  • (ArgumentError) 


108
109
110
111
 
# File 'lib/httpotato.rb', line 108

def default_timeout(t)
  raise ArgumentError, 'Timeout must be an integer' unless t && t.is_a?(Integer)
  default_options[:timeout] = t
end

#delete(path, options = {}) ⇒ Object

Perform a DELETE request to a path



279
280
281
 
# File 'lib/httpotato.rb', line 279

def delete(path, options={})
  perform_request Net::HTTP::Delete, path, options
end

#digest_auth(u, p) ⇒ Object

Allows setting digest authentication username and password.

class Foo
  include HTTPotato
  digest_auth 'username', 'password'
end



84
85
86
 
# File 'lib/httpotato.rb', line 84

def digest_auth(u, p)
  default_options[:digest_auth] = {:username => u, :password => p}
end

#format(f = nil) ⇒ Object

Allows setting the format with which to parse. Must be one of the allowed formats ie: json, xml

class Foo
  include HTTPotato
  format :json
end



148
149
150
151
152
153
154
155
156
 
# File 'lib/httpotato.rb', line 148

def format(f = nil)
  if f.nil?
    default_options[:format]
  else
    parser(Parser) if parser.nil?
    default_options[:format] = f
    validate_format
  end
end

#get(path, options = {}) ⇒ Object

Allows making a get request to a url.

class Foo
  include HTTPotato
end

# Simple get with full url
Foo.get('http://foo.com/resource.json')

# Simple get with full url and query parameters
# ie: http://foo.com/resource.json?limit=10
Foo.get('http://foo.com/resource.json', :query => {:limit => 10})



253
254
255
 
# File 'lib/httpotato.rb', line 253

def get(path, options={})
  perform_request Net::HTTP::Get, path, options
end

#head(path, options = {}) ⇒ Object

Perform a HEAD request to a path



284
285
286
 
# File 'lib/httpotato.rb', line 284

def head(path, options={})
  perform_request Net::HTTP::Head, path, options
end

#headers(h = {}) ⇒ Object

Allows setting HTTP headers to be used for each request.

class Foo
  include HTTPotato
  headers 'Accept' => 'text/html'
end

Raises:

  • (ArgumentError) 


130
131
132
133
134
 
# File 'lib/httpotato.rb', line 130

def headers(h={})
  raise ArgumentError, 'Headers must be a hash' unless h.is_a?(Hash)
  default_options[:headers] ||= {}
  default_options[:headers].merge!(h)
end

#http_proxy(addr = nil, port = nil) ⇒ Object

Allows setting http proxy information to be used

class Foo
  include HTTPotato
  http_proxy 'http://foo.com', 80
end



51
52
53
54
 
# File 'lib/httpotato.rb', line 51

def http_proxy(addr=nil, port = nil)
  default_options[:http_proxyaddr] = addr
  default_options[:http_proxyport] = port
end

#maintain_method_across_redirects(value = true) ⇒ Object

Declare that you wish to maintain the chosen HTTP method across redirects. The default behavior is to follow redirects via the GET method. If you wish to maintain the original method, you can set this option to true.

Examples:

class Foo
  include HTTPotato
  base_uri 'http://google.com'
  maintain_method_across_redirects true
end


192
193
194
 
# File 'lib/httpotato.rb', line 192

def maintain_method_across_redirects(value = true)
  default_options[:maintain_method_across_redirects] = value
end

#no_follow(value = false) ⇒ Object

Declare whether or not to follow redirects. When true, an RedirectionTooDeep error will raise upon encountering a redirect. You can then gain access to the response object via HTTPotato::RedirectionTooDeep#response.

Examples:

class Foo
  include HTTPotato
  base_uri 'http://google.com'
  no_follow true
end

begin
  Foo.get('/')
rescue HTTPotato::RedirectionTooDeep => e
  puts e.response.body
end

See Also:



177
178
179
 
# File 'lib/httpotato.rb', line 177

def no_follow(value = false)
  default_options[:no_follow] = value
end

#options(path, options = {}) ⇒ Object

Perform an OPTIONS request to a path



289
290
291
 
# File 'lib/httpotato.rb', line 289

def options(path, options={})
  perform_request Net::HTTP::Options, path, options
end

#parser(custom_parser = nil) ⇒ Object

Allows setting a custom parser for the response.

class Foo
  include HTTPotato
  parser Proc.new {|data| ...}
end



232
233
234
235
236
237
238
239
 
# File 'lib/httpotato.rb', line 232

def parser(custom_parser = nil)
  if custom_parser.nil?
    default_options[:parser]
  else
    default_options[:parser] = custom_parser
    validate_format
  end
end

#pem(pem_contents) ⇒ Object

Allows setting a PEM file to be used

class Foo
  include HTTPotato
  pem File.read('/home/user/my.pem')
end



202
203
204
 
# File 'lib/httpotato.rb', line 202

def pem(pem_contents)
  default_options[:pem] = pem_contents
end

#post(path, options = {}) ⇒ Object

Allows making a post request to a url.

class Foo
  include HTTPotato
end

# Simple post with full url and setting the body
Foo.post('http://foo.com/resources', :body => {:bar => 'baz'})

# Simple post with full url using :query option,
# which gets set as form data on the request.
Foo.post('http://foo.com/resources', :query => {:bar => 'baz'})



269
270
271
 
# File 'lib/httpotato.rb', line 269

def post(path, options={})
  perform_request Net::HTTP::Post, path, options
end

#put(path, options = {}) ⇒ Object

Perform a PUT request to a path



274
275
276
 
# File 'lib/httpotato.rb', line 274

def put(path, options={})
  perform_request Net::HTTP::Put, path, options
end

#ssl_ca_file(path) ⇒ Object

Allows setting an OpenSSL certificate authority file

class Foo
  include HTTPotato
  ssl_ca_file '/etc/ssl/certs/ca-certificates.crt'
end



212
213
214
 
# File 'lib/httpotato.rb', line 212

def ssl_ca_file(path)
  default_options[:ssl_ca_file] = path
end

#ssl_ca_path(path) ⇒ Object

Allows setting an OpenSSL certificate authority path (directory)

class Foo
  include HTTPotato
  ssl_ca_path '/etc/ssl/certs/'
end



222
223
224
 
# File 'lib/httpotato.rb', line 222

def ssl_ca_path(path)
  default_options[:ssl_ca_path] = path
end