yyyc514-httparty 0.4.4.2

data/examples/delicious.rb

@@ -0,0 +1,37 @@
+dir = File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib'))
+require File.join(dir, 'httparty')
+require 'pp'
+config = YAML::load(File.read(File.join(ENV['HOME'], '.delicious')))
+
+class Delicious
+  include HTTParty
+  base_uri 'https://api.del.icio.us/v1'
+  
+  def initialize(u, p)
+    @auth = {:username => u, :password => p}
+  end
+  
+  # query params that filter the posts are:
+  #   tag (optional). Filter by this tag.
+  #   dt (optional). Filter by this date (CCYY-MM-DDThh:mm:ssZ).
+  #   url (optional). Filter by this url.
+  #   ie: posts(:query => {:tag => 'ruby'})
+  def posts(options={})
+    options.merge!({:basic_auth => @auth})
+    self.class.get('/posts/get', options)
+  end
+  
+  # query params that filter the posts are:
+  #   tag (optional). Filter by this tag.
+  #   count (optional). Number of items to retrieve (Default:15, Maximum:100).
+  def recent(options={})
+    options.merge!({:basic_auth => @auth})
+    self.class.get('/posts/recent', options)
+  end
+end
+
+delicious = Delicious.new(config['username'], config['password'])
+pp delicious.posts(:query => {:tag => 'ruby'})
+pp delicious.recent
+
+delicious.recent['posts']['post'].each { |post| puts post['href'] }

data/examples/google.rb

@@ -0,0 +1,16 @@
+dir = File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib'))
+require File.join(dir, 'httparty')
+require 'pp'
+
+class Google
+  include HTTParty
+  format :html
+end
+
+# google.com redirects to www.google.com so this is live test for redirection
+pp Google.get('http://google.com')
+
+puts '', '*'*70, ''
+
+# check that ssl is requesting right
+pp Google.get('https://www.google.com')

data/examples/rubyurl.rb

@@ -0,0 +1,14 @@
+dir = File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib'))
+require File.join(dir, 'httparty')
+require 'pp'
+
+class Rubyurl
+  include HTTParty
+  base_uri 'rubyurl.com'
+
+  def self.shorten( website_url )
+    post( '/api/links.json', :query => { :link => { :website_url => website_url } } )
+  end
+end
+
+pp Rubyurl.shorten( 'http://istwitterdown.com/')

data/examples/twitter.rb

@@ -0,0 +1,31 @@
+dir = File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib'))
+require File.join(dir, 'httparty')
+require 'pp'
+config = YAML::load(File.read(File.join(ENV['HOME'], '.twitter')))
+
+class Twitter
+  include HTTParty
+  base_uri 'twitter.com'
+  
+  def initialize(u, p)
+    @auth = {:username => u, :password => p}
+  end
+  
+  # which can be :friends, :user or :public
+  # options[:query] can be things like since, since_id, count, etc.
+  def timeline(which=:friends, options={})
+    options.merge!({:basic_auth => @auth})
+    self.class.get("/statuses/#{which}_timeline.json", options)
+  end
+  
+  def post(text)
+    options = { :query => {:status => text}, :basic_auth => @auth }
+    self.class.post('/statuses/update.json', options)
+  end
+end
+
+twitter = Twitter.new(config['email'], config['password'])
+pp twitter.timeline
+# pp twitter.timeline(:friends, :query => {:since_id => 868482746})
+# pp twitter.timeline(:friends, :query => 'since_id=868482746')
+# pp twitter.post('this is a test of 0.2.0')

data/examples/whoismyrep.rb

@@ -0,0 +1,10 @@
+dir = File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib'))
+require File.join(dir, 'httparty')
+require 'pp'
+
+class Rep
+  include HTTParty
+end
+
+pp Rep.get('http://whoismyrepresentative.com/whoismyrep.php?zip=46544')
+pp Rep.get('http://whoismyrepresentative.com/whoismyrep.php', :query => {:zip => 46544})

data/features/basic_authentication.feature

@@ -0,0 +1,20 @@
+Feature:  Basic Authentication
+
+  As a developer
+  I want to be able to use a service that requires Basic Authentication
+  Because that is not an uncommon requirement
+
+  Scenario: Passing no credentials to a page requiring Basic Authentication
+    Given a restricted page at '/protected.html'
+    When I call HTTParty#get with '/protected.html'
+    Then it should return a response with a 401 response code
+
+  Scenario: Passing proper credentials to a page requiring Basic Authentication
+    Given a remote service that returns 'Authenticated Page'
+    And that service is accessed at the path '/protected.html'
+    And that service is protected by Basic Authentication
+    And that service requires the username 'jcash' with the password 'maninblack'
+    When I call HTTParty#get with '/protected.html' and a basic_auth hash:
+       | username | password   |
+       | jcash    | maninblack |
+    Then the return value should match 'Authenticated Page'

data/features/command_line.feature

@@ -0,0 +1,7 @@
+Feature: Command Line
+
+  As a developer
+  I want to be able to harness the power of HTTParty from the command line
+  Because that would make quick testing and debugging easy
+  And 'easy' is my middle name
+  And I'm kidding it's actually 'Danger'!

data/features/deals_with_http_error_codes.feature

@@ -0,0 +1,26 @@
+Feature: Deals with HTTP error codes
+
+  As a developer
+  I want to be informed of non-successful responses
+  Because sometimes thing explode
+  And I should probably know what happened
+
+  Scenario: A response of '404 - Not Found'
+    Given a remote service that returns a 404 status code
+    And that service is accessed at the path '/service.html'
+    When I call HTTParty#get with '/service.html'
+    Then it should return a response with a 404 response code
+
+  Scenario: A response of '500 - Internal Server Error'
+    Given a remote service that returns a 500 status code
+    And that service is accessed at the path '/service.html'
+    When I call HTTParty#get with '/service.html'
+    Then it should return a response with a 500 response code
+
+  Scenario: A non-successful response where I need the body
+    Given a remote service that returns a 400 status code
+    And the response from the service has a body of 'Bad response'
+    And that service is accessed at the path '/service.html'
+    When I call HTTParty#get with '/service.html'
+    Then it should return a response with a 400 response code
+    And the return value should match 'Bad response'

data/features/handles_multiple_formats.feature

@@ -0,0 +1,34 @@
+Feature: Handles Multiple Formats
+
+  As a developer
+  I want to be able to consume remote services of many different formats
+  And I want those formats to be automatically detected and handled
+  Because web services take many forms
+  And I don't want to have to do any extra work
+
+  Scenario: An HTML service
+    Given a remote service that returns '<h1>Some HTML</h1>'
+    And that service is accessed at the path '/service.html'
+    And the response from the service has a Content-Type of 'text/html'
+    When I call HTTParty#get with '/service.html'
+    Then it should return a String
+    And the return value should match '<h1>Some HTML</h1>'
+
+  Scenario: A JSON service
+    Given a remote service that returns '{ "jennings": "waylon", "cash": "johnny" }'
+    And that service is accessed at the path '/service.json'
+    And the response from the service has a Content-Type of 'application/json'
+    When I call HTTParty#get with '/service.json'
+    Then it should return a Hash equaling:
+       | key      | value  |
+       | jennings | waylon |
+       | cash     | johnny |
+
+  Scenario: An XML Service
+    Given a remote service that returns '<singer>waylon jennings</singer>'
+    And that service is accessed at the path '/service.xml'
+    And the response from the service has a Content-Type of 'text/xml'
+    When I call HTTParty#get with '/service.xml'
+    Then it should return a Hash equaling:
+       | key    | value           |
+       | singer | waylon jennings |

data/features/steps/env.rb

@@ -0,0 +1,15 @@
+require 'mongrel'
+require 'activesupport'
+require 'lib/httparty'
+require 'spec/expectations'
+
+Before do
+  port = ENV["HTTPARTY_PORT"] || 31981
+  @host_and_port = "0.0.0.0:#{port}"
+  @server = Mongrel::HttpServer.new("0.0.0.0", port)
+  @server.run
+end
+
+After do
+  @server.stop
+end

data/features/steps/httparty_response_steps.rb

@@ -0,0 +1,26 @@
+Then /it should return an? (\w+)$/ do |class_string|
+  @response_from_httparty.should be_an_instance_of(class_string.constantize)
+end
+
+Then /the return value should match '(.*)'/ do |expected_text|
+  @response_from_httparty.should eql(expected_text)
+end
+
+Then /it should return a Hash equaling:/ do |hash_table|
+  @response_from_httparty.should be_an_instance_of(Hash)
+  @response_from_httparty.keys.length.should eql(hash_table.rows.length)
+  hash_table.hashes.each do |pair|
+    key, value = pair["key"], pair["value"]
+    @response_from_httparty.keys.should include(key)
+    @response_from_httparty[key].should eql(value)
+  end
+end
+
+Then /it should return a response with a (\d+) response code/ do |code|
+  @response_from_httparty.code.should eql(code.to_i)
+end
+
+Then /it should raise an HTTParty::RedirectionTooDeep exception/ do
+  @exception_from_httparty.should_not be_nil
+  @exception_from_httparty.class.should eql(HTTParty::RedirectionTooDeep)
+end

data/features/steps/httparty_steps.rb

@@ -0,0 +1,15 @@
+When /I call HTTParty#get with '(.*)'$/ do |url|
+  begin
+    @response_from_httparty = HTTParty.get("http://#{@host_and_port}#{url}")
+  rescue HTTParty::RedirectionTooDeep => e
+    @exception_from_httparty = e
+  end
+end
+
+When /I call HTTParty#get with '(.*)' and a basic_auth hash:/ do |url, auth_table|
+  h = auth_table.hashes.first
+  @response_from_httparty = HTTParty.get(
+    "http://#{@host_and_port}#{url}",
+    :basic_auth => { :username => h["username"], :password => h["password"] }
+  )
+end

data/features/steps/mongrel_helper.rb

@@ -0,0 +1,55 @@
+def basic_mongrel_handler
+  Class.new(Mongrel::HttpHandler) do
+    attr_writer :content_type, :response_body, :response_code
+
+    def initialize
+      @content_type = "text/html"
+      @response_body = ""
+      @response_code = 200
+      @custom_headers = {}
+    end
+
+    def process(request, response)
+      reply_with(response, @response_code, @response_body)
+    end
+
+    def reply_with(response, code, response_body)
+      response.start(code) do |head, body|
+        head["Content-Type"] = @content_type
+        @custom_headers.each { |k,v| head[k] = v }
+        body.write(response_body)
+      end
+    end
+  end
+end
+
+def new_mongrel_handler
+  basic_mongrel_handler.new
+end
+
+def add_basic_authentication_to(handler)
+  m = Module.new do
+    attr_writer :username, :password
+
+    def self.extended(base)
+      base.instance_eval { @custom_headers["WWW-Authenticate"] = 'Basic Realm="Super Secret Page"' }
+      base.class_eval { alias_method_chain :process, :basic_authentication }
+    end
+
+    def process_with_basic_authentication(request, response)
+      if authorized?(request) then process_without_basic_authentication(request, response)
+      else reply_with(response, 401, "Incorrect.  You have 20 seconds to comply.")
+      end
+    end
+
+    def authorized?(request)
+      request.params["HTTP_AUTHORIZATION"] == "Basic " + Base64.encode64("#{@username}:#{@password}").strip
+    end
+  end
+  handler.extend(m)
+end
+
+def new_mongrel_redirector(target_url, relative_path = false)
+  target_url = "http://#{@host_and_port}#{target_url}" unless relative_path
+  Mongrel::RedirectHandler.new(target_url)
+end

data/features/steps/remote_service_steps.rb

@@ -0,0 +1,47 @@
+Given /a remote service that returns '(.*)'/ do |response_body|
+  @handler = new_mongrel_handler
+  Given "the response from the service has a body of '#{response_body}'"
+end
+
+Given /a remote service that returns a (\d+) status code/ do |code|
+  @handler = new_mongrel_handler
+  @handler.response_code = code
+end
+
+Given /that service is accessed at the path '(.*)'/ do |path|
+  @server.register(path, @handler)
+end
+
+Given /the response from the service has a Content-Type of '(.*)'/ do |content_type|
+  @handler.content_type = content_type
+end
+
+Given /the response from the service has a body of '(.*)'/ do |response_body|
+  @handler.response_body = response_body
+end
+
+Given /the url '(.*)' redirects to '(.*)'/ do |redirection_url, target_url|
+  @server.register redirection_url, new_mongrel_redirector(target_url)
+end
+
+Given /that service is protected by Basic Authentication/ do
+  add_basic_authentication_to @handler
+end
+
+Given /that service requires the username '(.*)' with the password '(.*)'/ do |username, password|
+  @handler.username = username
+  @handler.password = password
+end
+
+Given /a restricted page at '(.*)'/ do |url|
+  Given "a remote service that returns 'A response I will never see'"
+  And "that service is accessed at the path '#{url}'"
+  And "that service is protected by Basic Authentication"
+  And "that service requires the username 'something' with the password 'secret'"
+end
+
+# This joins the server thread, and halts cucumber, so you can actually hit the
+# server with a browser.  Runs until you kill it with Ctrl-c
+Given /I want to hit this in a browser/ do
+  @server.acceptor.join
+end

data/features/supports_redirection.feature

@@ -0,0 +1,22 @@
+Feature: Supports Redirection
+
+  As a developer
+  I want to work with services that may redirect me
+  And I want it to follow a reasonable number of redirects
+  Because sometimes web services do that
+
+  Scenario: A service that redirects once
+    Given a remote service that returns 'Service Response'
+    And that service is accessed at the path '/service.html'
+    And the url '/redirector.html' redirects to '/service.html'
+    When I call HTTParty#get with '/redirector.html'
+    Then the return value should match 'Service Response'
+
+  # TODO: Look in to why this actually fails...
+  Scenario: A service that redirects to a relative URL
+
+  Scenario: A service that redirects infinitely
+    Given the url '/first.html' redirects to '/second.html'
+    And the url '/second.html' redirects to '/first.html'
+    When I call HTTParty#get with '/first.html'
+    Then it should raise an HTTParty::RedirectionTooDeep exception

data/lib/httparty.rb

@@ -0,0 +1,206 @@
+$:.unshift(File.dirname(__FILE__))
+
+require 'net/http'
+require 'net/https'
+require 'httparty/class_inheritable_attributes'
+require 'rubygems'
+gem 'crack'
+require 'crack'
+
+require 'httparty/cookie_hash'
+
+module HTTParty
+  
+  AllowedFormats = {
+    'text/xml'               => :xml,
+    'application/xml'        => :xml,
+    'application/json'       => :json,
+    'text/json'              => :json,
+    'application/javascript' => :json,
+    'text/javascript'        => :json,
+    'text/html'              => :html,
+    'application/x-yaml'     => :yaml,
+    'text/yaml'              => :yaml,
+    'text/plain'             => :plain
+  } unless defined?(AllowedFormats)
+  
+  def self.included(base)
+    base.extend ClassMethods
+    base.send :include, HTTParty::ClassInheritableAttributes
+    base.send(:cattr_inheritable, :default_options)
+    base.send(:cattr_inheritable, :default_cookies)
+    base.instance_variable_set("@default_options", {})
+    base.instance_variable_set("@default_cookies", CookieHash.new)
+  end
+  
+  module ClassMethods
+    # Allows setting http proxy information to be used
+    #
+    #   class Foo
+    #     include HTTParty
+    #     http_proxy 'http://foo.com', 80
+    #   end
+    def http_proxy(addr=nil, port = nil)
+      default_options[:http_proxyaddr] = addr
+      default_options[:http_proxyport] = port
+    end
+    
+    # Allows setting a base uri to be used for each request.
+    # Will normalize uri to include http, etc.
+    #
+    #   class Foo
+    #     include HTTParty
+    #     base_uri 'twitter.com'
+    #   end
+    def base_uri(uri=nil)
+      return default_options[:base_uri] unless uri
+      default_options[:base_uri] = HTTParty.normalize_base_uri(uri)
+    end
+    
+    # Allows setting basic authentication username and password.
+    #
+    #   class Foo
+    #     include HTTParty
+    #     basic_auth 'username', 'password'
+    #   end
+    def basic_auth(u, p)
+      default_options[:basic_auth] = {:username => u, :password => p}
+    end
+    
+    # Allows setting default parameters to be appended to each request.
+    # Great for api keys and such.
+    #
+    #   class Foo
+    #     include HTTParty
+    #     default_params :api_key => 'secret', :another => 'foo'
+    #   end
+    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
+    
+    # Allows setting a base uri to be used for each request.
+    #
+    #   class Foo
+    #     include HTTParty
+    #     headers 'Accept' => 'text/html'
+    #   end
+    def headers(h={})
+      raise ArgumentError, 'Headers must be a hash' unless h.is_a?(Hash)
+      default_options[:headers] ||= {}
+      default_options[:headers].merge!(h)
+    end
+
+    def cookies(h={})
+      raise ArgumentError, 'Cookies must be a hash' unless h.is_a?(Hash)
+      default_cookies.add_cookies(h)
+    end
+    
+    # Allows setting the format with which to parse.
+    # Must be one of the allowed formats ie: json, xml
+    #
+    #   class Foo
+    #     include HTTParty
+    #     format :json
+    #   end
+    def format(f)
+      raise UnsupportedFormat, "Must be one of: #{AllowedFormats.values.map { |v| v.to_s }.uniq.sort.join(', ')}" unless AllowedFormats.value?(f)
+      default_options[:format] = f
+    end
+    
+    # Allows making a get request to a url.
+    #
+    #   class Foo
+    #     include HTTParty
+    #   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})
+    def get(path, options={})
+      perform_request Net::HTTP::Get, path, options
+    end
+    
+    # Allows making a post request to a url.
+    #
+    #   class Foo
+    #     include HTTParty
+    #   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'})
+    def post(path, options={})
+      perform_request Net::HTTP::Post, path, options
+    end
+
+    def put(path, options={})
+      perform_request Net::HTTP::Put, path, options
+    end
+
+    def delete(path, options={})
+      perform_request Net::HTTP::Delete, path, options
+    end
+    
+    def default_options #:nodoc:
+      @default_options
+    end
+
+    private
+      def perform_request(http_method, path, options) #:nodoc:
+        process_cookies(options)
+        Request.new(http_method, path, default_options.dup.merge(options)).perform
+      end
+
+      def process_cookies(options) #:nodoc:
+        return unless options[:cookies] || default_cookies
+        options[:headers] ||= {}
+        options[:headers]["cookie"] = cookies.merge(options[:cookies] || {}).to_cookie_string
+
+        options.delete(:cookies)
+      end
+  end
+
+  def self.normalize_base_uri(url) #:nodoc:
+    normalized_url = url.dup
+    use_ssl = (normalized_url =~ /^https/) || normalized_url.include?(':443')
+    ends_with_slash = normalized_url =~ /\/$/
+    
+    normalized_url.chop! if ends_with_slash
+    normalized_url.gsub!(/^https?:\/\//i, '')
+    
+    "http#{'s' if use_ssl}://#{normalized_url}"
+  end
+  
+  class Basement #:nodoc:
+    include HTTParty
+  end
+  
+  def self.get(*args)
+    Basement.get(*args)
+  end
+  
+  def self.post(*args)
+    Basement.post(*args)
+  end
+
+  def self.put(*args)
+    Basement.put(*args)
+  end
+
+  def self.delete(*args)
+    Basement.delete(*args)
+  end
+end
+
+require 'httparty/core_extensions'
+require 'httparty/exceptions'
+require 'httparty/request'
+require 'httparty/response'