jcinnamond-httparty 0.4.5

data/features/supports_timeout_option.feature

@@ -0,0 +1,12 @@
+Feature: Supports the timeout option
+  In order to handle inappropriately slow response times
+  As a developer
+  I want my request to raise an exception after my specified timeout as elapsed
+
+  Scenario: A long running response
+    Given a remote service that returns '<h1>Some HTML</h1>'
+    And that service is accessed at the path '/service.html'
+    And that service takes 2 seconds to generate a response
+    When I set my HTTParty timeout option to 1
+    And I call HTTParty#get with '/service.html'
+    Then it should raise a Timeout::Error exception

data/httparty.gemspec

@@ -0,0 +1,109 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE
+# Instead, edit Jeweler::Tasks in Rakefile, and run `rake gemspec`
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{httparty}
+  s.version = "0.4.5"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["John Nunemaker"]
+  s.date = %q{2009-09-12}
+  s.default_executable = %q{httparty}
+  s.description = %q{Makes http fun! Also, makes consuming restful web services dead easy.}
+  s.email = %q{nunemaker@gmail.com}
+  s.executables = ["httparty"]
+  s.extra_rdoc_files = [
+    "README.rdoc"
+  ]
+  s.files = [
+    ".gitignore",
+     "History",
+     "MIT-LICENSE",
+     "Manifest",
+     "README.rdoc",
+     "Rakefile",
+     "VERSION",
+     "bin/httparty",
+     "cucumber.yml",
+     "examples/aaws.rb",
+     "examples/basic.rb",
+     "examples/delicious.rb",
+     "examples/google.rb",
+     "examples/rubyurl.rb",
+     "examples/twitter.rb",
+     "examples/whoismyrep.rb",
+     "features/basic_authentication.feature",
+     "features/command_line.feature",
+     "features/deals_with_http_error_codes.feature",
+     "features/handles_multiple_formats.feature",
+     "features/steps/env.rb",
+     "features/steps/httparty_response_steps.rb",
+     "features/steps/httparty_steps.rb",
+     "features/steps/mongrel_helper.rb",
+     "features/steps/remote_service_steps.rb",
+     "features/supports_redirection.feature",
+     "features/supports_timeout_option.feature",
+     "httparty.gemspec",
+     "lib/httparty.rb",
+     "lib/httparty/cookie_hash.rb",
+     "lib/httparty/core_extensions.rb",
+     "lib/httparty/exceptions.rb",
+     "lib/httparty/module_inheritable_attributes.rb",
+     "lib/httparty/request.rb",
+     "lib/httparty/response.rb",
+     "lib/httparty/version.rb",
+     "spec/fixtures/delicious.xml",
+     "spec/fixtures/empty.xml",
+     "spec/fixtures/google.html",
+     "spec/fixtures/twitter.json",
+     "spec/fixtures/twitter.xml",
+     "spec/fixtures/undefined_method_add_node_for_nil.xml",
+     "spec/httparty/cookie_hash_spec.rb",
+     "spec/httparty/request_spec.rb",
+     "spec/httparty/response_spec.rb",
+     "spec/httparty_spec.rb",
+     "spec/spec.opts",
+     "spec/spec_helper.rb",
+     "website/css/common.css",
+     "website/index.html"
+  ]
+  s.has_rdoc = true
+  s.homepage = %q{http://httparty.rubyforge.org}
+  s.post_install_message = %q{When you HTTParty, you must party hard!}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.1}
+  s.summary = %q{Makes http fun! Also, makes consuming restful web services dead easy.}
+  s.test_files = [
+    "spec/httparty/cookie_hash_spec.rb",
+     "spec/httparty/request_spec.rb",
+     "spec/httparty/response_spec.rb",
+     "spec/httparty_spec.rb",
+     "spec/spec_helper.rb",
+     "examples/aaws.rb",
+     "examples/basic.rb",
+     "examples/delicious.rb",
+     "examples/google.rb",
+     "examples/rubyurl.rb",
+     "examples/twitter.rb",
+     "examples/whoismyrep.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 2
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<crack>, [">= 0.1.1"])
+      s.add_development_dependency(%q<rspec>, ["= 1.2.8"])
+    else
+      s.add_dependency(%q<crack>, [">= 0.1.1"])
+      s.add_dependency(%q<rspec>, ["= 1.2.8"])
+    end
+  else
+    s.add_dependency(%q<crack>, [">= 0.1.1"])
+    s.add_dependency(%q<rspec>, ["= 1.2.8"])
+  end
+end

data/lib/httparty.rb

@@ -0,0 +1,216 @@
+require 'pathname'
+require 'net/http'
+require 'net/https'
+require 'rubygems'
+gem 'crack', '>= 0.1.1'
+require 'crack'
+
+dir = Pathname(__FILE__).dirname.expand_path
+
+require dir + 'httparty/module_inheritable_attributes'
+require dir + '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::ModuleInheritableAttributes
+    base.send(:mattr_inheritable, :default_options)
+    base.send(:mattr_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 setting a custom parser for the response.
+    #
+    #   class Foo
+    #     include HTTParty
+    #     parser Proc.new {|data| ...}
+    #   end
+    def parser(customer_parser)
+      default_options[:parser] = customer_parser
+    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:
+        options = default_options.dup.merge(options)
+        process_cookies(options)
+        Request.new(http_method, path, options).perform
+      end
+
+      def process_cookies(options) #:nodoc:
+        return unless options[:cookies] || default_cookies.any?
+        options[:headers] ||= headers.dup
+        options[:headers]["cookie"] = cookies.merge(options.delete(:cookies) || {}).to_cookie_string
+      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 dir + 'httparty/core_extensions'
+require dir + 'httparty/exceptions'
+require dir + 'httparty/request'
+require dir + 'httparty/response'

data/lib/httparty/cookie_hash.rb

@@ -0,0 +1,22 @@
+class HTTParty::CookieHash < Hash #:nodoc:
+  
+  CLIENT_COOKIES = %w{path expires domain path secure HTTPOnly}
+  
+  def add_cookies(value)
+    case value
+    when Hash
+      merge!(value)
+    when String
+      value.split('; ').each do |cookie|
+        array = cookie.split('=')
+        self[array[0].to_sym] = array[1]
+      end
+    else
+      raise "add_cookies only takes a Hash or a String"
+    end
+  end
+
+  def to_cookie_string
+    delete_if { |k, v| CLIENT_COOKIES.include?(k.to_s) }.collect { |k, v| "#{k}=#{v}" }.join("; ")
+  end
+end

data/lib/httparty/core_extensions.rb

@@ -0,0 +1,25 @@
+class BasicObject #:nodoc:
+  instance_methods.each { |m| undef_method m unless m =~ /^__|instance_eval/ }
+end unless defined?(BasicObject)
+ 
+# 1.8.6 has mistyping of transitive in if statement
+require "rexml/document"
+module REXML #:nodoc:
+  class Document < Element #:nodoc:
+    def write( output=$stdout, indent=-1, transitive=false, ie_hack=false )
+      if xml_decl.encoding != "UTF-8" && !output.kind_of?(Output)
+        output = Output.new( output, xml_decl.encoding )
+      end
+      formatter = if indent > -1
+          if transitive
+            REXML::Formatters::Transitive.new( indent, ie_hack )
+          else
+            REXML::Formatters::Pretty.new( indent, ie_hack )
+          end
+        else
+          REXML::Formatters::Default.new( ie_hack )
+        end
+      formatter.write( self, output )
+    end
+  end
+end

data/lib/httparty/exceptions.rb

@@ -0,0 +1,7 @@
+module HTTParty
+  # Exception raised when you attempt to set a non-existant format
+  class UnsupportedFormat < StandardError; end
+  
+  # Exception that is raised when request has redirected too many times
+  class RedirectionTooDeep < StandardError; end
+end

data/lib/httparty/module_inheritable_attributes.rb

@@ -0,0 +1,25 @@
+module HTTParty
+  module ModuleInheritableAttributes #:nodoc:
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods #:nodoc:
+      def mattr_inheritable(*args)
+        @mattr_inheritable_attrs ||= [:mattr_inheritable_attrs]
+        @mattr_inheritable_attrs += args
+        args.each do |arg|
+          module_eval %(class << self; attr_accessor :#{arg} end)
+        end
+        @mattr_inheritable_attrs
+      end
+
+      def inherited(subclass)
+        @mattr_inheritable_attrs.each do |inheritable_attribute|
+          instance_var = "@#{inheritable_attribute}" 
+          subclass.instance_variable_set(instance_var, instance_variable_get(instance_var))
+        end
+      end
+    end
+  end
+end

data/lib/httparty/request.rb

@@ -0,0 +1,178 @@
+require 'uri'
+
+module HTTParty
+  class Request #:nodoc:
+    SupportedHTTPMethods = [Net::HTTP::Get, Net::HTTP::Post, Net::HTTP::Put, Net::HTTP::Delete]
+    
+    attr_accessor :http_method, :path, :options
+    
+    def initialize(http_method, path, o={})
+      self.http_method = http_method
+      self.path = path
+      self.options = {
+        :limit => o.delete(:no_follow) ? 0 : 5, 
+        :default_params => {},
+      }.merge(o)
+    end
+
+    def path=(uri)
+      @path = URI.parse(uri)
+    end
+    
+    def uri
+      new_uri = path.relative? ? URI.parse("#{options[:base_uri]}#{path}") : path
+      print "Uri: #{new_uri} "
+      
+      # avoid double query string on redirects [#12]
+      unless @redirect
+        new_uri.query = query_string(new_uri)
+      end
+      puts "... #{new_uri}"
+
+      new_uri
+    end
+    
+    def format
+      options[:format]
+    end
+    
+    def perform
+      validate
+      setup_raw_request
+      handle_response(get_response)
+    end
+
+    private
+
+      def http
+        http = Net::HTTP.new(uri.host, uri.port, options[:http_proxyaddr], options[:http_proxyport])
+        http.use_ssl = (uri.port == 443)
+        http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+        if options[:timeout] && options[:timeout].is_a?(Integer)
+          http.open_timeout = options[:timeout]
+          http.read_timeout = options[:timeout]
+        end
+        http
+      end
+
+      def body
+        options[:body].is_a?(Hash) ? options[:body].to_params : options[:body]
+      end
+      
+      def username
+        options[:basic_auth][:username]
+      end
+      
+      def password
+        options[:basic_auth][:password]
+      end
+
+      def setup_raw_request
+        @raw_request = http_method.new(uri.request_uri)
+        @raw_request.body = body if body
+        @raw_request.initialize_http_header(options[:headers])
+        @raw_request.basic_auth(username, password) if options[:basic_auth]
+      end
+
+      def perform_actual_request
+        http.request(@raw_request)
+      end
+
+      def get_response
+        response = perform_actual_request
+        options[:format] ||= format_from_mimetype(response['content-type'])
+        response
+      end
+      
+      def query_string(uri)
+        query_string_parts = []
+        query_string_parts << uri.query unless uri.query.nil?
+
+        if options[:query].is_a?(Hash)
+          query_string_parts << options[:default_params].merge(options[:query]).to_params
+        else
+          query_string_parts << options[:default_params].to_params unless options[:default_params].nil? || options[:default_params].empty?
+          query_string_parts << options[:query] unless options[:query].nil?
+        end
+        
+        print "[ qsp = #{query_string_parts.inspect}, options[default_params] = #{options[:default_params].inspect} ]"
+        query_string_parts.size > 0 ? query_string_parts.join('&') : nil
+      end
+      
+      # Raises exception Net::XXX (http error code) if an http error occured
+      def handle_response(response)
+        case response
+          when Net::HTTPRedirection
+            options[:limit] -= 1
+            self.path = response['location']
+            @redirect = true
+            self.http_method = Net::HTTP::Get
+            capture_cookies(response)
+            perform
+          else
+            parsed_response = parse_response(response.body)
+            Response.new(parsed_response, response.body, response.code, response.message, response.to_hash)
+          end
+      end
+      
+      # HTTParty.const_get((self.format.to_s || 'text').capitalize)
+      def parse_response(body)
+        return nil if body.nil? or body.empty?
+        if options[:parser].blank?
+          case format
+            when :xml
+              Crack::XML.parse(body)
+            when :json
+              Crack::JSON.parse(body)
+            when :yaml
+              YAML::load(body)
+            else
+              body
+            end
+        else
+          if options[:parser].is_a?(Proc)
+            options[:parser].call(body)
+          else
+            body
+          end
+        end
+      end
+            
+      def capture_cookies(response)
+        return unless response['Set-Cookie']
+        cookies_hash = HTTParty::CookieHash.new()
+        cookies_hash.add_cookies(options[:headers]['Cookie']) if options[:headers] && options[:headers]['Cookie']
+        cookies_hash.add_cookies(response['Set-Cookie'])
+        options[:headers] ||= {}
+        options[:headers]['Cookie'] = cookies_hash.to_cookie_string
+      end
+      
+      def capture_cookies(response)
+        return unless response['Set-Cookie']
+        cookies_hash = HTTParty::CookieHash.new()
+        cookies_hash.add_cookies(options[:headers]['Cookie']) if options[:headers] && options[:headers]['Cookie']
+        cookies_hash.add_cookies(response['Set-Cookie'])
+        options[:headers] ||= {}
+        options[:headers]['Cookie'] = cookies_hash.to_cookie_string
+      end
+  
+      # Uses the HTTP Content-Type header to determine the format of the response
+      # It compares the MIME type returned to the types stored in the AllowedFormats hash
+      def format_from_mimetype(mimetype)
+        return nil if mimetype.nil?
+        AllowedFormats.each { |k, v| return v if mimetype.include?(k) }
+      end
+      
+      def validate
+        raise HTTParty::RedirectionTooDeep, 'HTTP redirects too deep' if options[:limit].to_i <= 0
+        raise ArgumentError, 'only get, post, put and delete methods are supported' unless SupportedHTTPMethods.include?(http_method)
+        raise ArgumentError, ':headers must be a hash' if options[:headers] && !options[:headers].is_a?(Hash)
+        raise ArgumentError, ':basic_auth must be a hash' if options[:basic_auth] && !options[:basic_auth].is_a?(Hash)
+        raise ArgumentError, ':query must be hash if using HTTP Post' if post? && !options[:query].nil? && !options[:query].is_a?(Hash)
+      end
+      
+      def post?
+        Net::HTTP::Post == http_method
+      end
+  end
+end