alexvollmer-httparty 0.1.5 → 0.2.6

data/lib/core_extensions.rb

@@ -0,0 +1,349 @@
+require 'time'
+
+# Copyright (c) 2008 Sam Smoot.
+# 
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+# 
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+# 
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+class Object
+  # @return <TrueClass, FalseClass>
+  #
+  # @example [].blank?         #=>  true
+  # @example [1].blank?        #=>  false
+  # @example [nil].blank?      #=>  false
+  # 
+  # Returns true if the object is nil or empty (if applicable)
+  def blank?
+    nil? || (respond_to?(:empty?) && empty?)
+  end
+end # class Object
+
+class Numeric
+  # @return <TrueClass, FalseClass>
+  # 
+  # Numerics can't be blank
+  def blank?
+    false
+  end
+end # class Numeric
+
+class NilClass
+  # @return <TrueClass, FalseClass>
+  # 
+  # Nils are always blank
+  def blank?
+    true
+  end
+end # class NilClass
+
+class TrueClass
+  # @return <TrueClass, FalseClass>
+  # 
+  # True is not blank.  
+  def blank?
+    false
+  end
+end # class TrueClass
+
+class FalseClass
+  # False is always blank.
+  def blank?
+    true
+  end
+end # class FalseClass
+
+class String
+  # @example "".blank?         #=>  true
+  # @example "     ".blank?    #=>  true
+  # @example " hey ho ".blank? #=>  false
+  # 
+  # @return <TrueClass, FalseClass>
+  # 
+  # Strips out whitespace then tests if the string is empty.
+  def blank?
+    strip.empty?
+  end
+end # class String
+
+require 'rexml/parsers/streamparser'
+require 'rexml/parsers/baseparser'
+require 'rexml/light/node'
+
+# This is a slighly modified version of the XMLUtilityNode from
+# http://merb.devjavu.com/projects/merb/ticket/95 (has.sox@gmail.com)
+# It's mainly just adding vowels, as I ht cd wth n vwls :)
+# This represents the hard part of the work, all I did was change the
+# underlying parser.
+class REXMLUtilityNode
+  attr_accessor :name, :attributes, :children, :type
+  
+  def self.typecasts
+    @@typecasts
+  end
+  
+  def self.typecasts=(obj)
+    @@typecasts = obj
+  end
+  
+  def self.available_typecasts
+    @@available_typecasts
+  end
+  
+  def self.available_typecasts=(obj)
+    @@available_typecasts = obj
+  end
+
+  self.typecasts = {}
+  self.typecasts["integer"]       = lambda{|v| v.nil? ? nil : v.to_i}
+  self.typecasts["boolean"]       = lambda{|v| v.nil? ? nil : (v.strip != "false")}
+  self.typecasts["datetime"]      = lambda{|v| v.nil? ? nil : Time.parse(v).utc}
+  self.typecasts["date"]          = lambda{|v| v.nil? ? nil : Date.parse(v)}
+  self.typecasts["dateTime"]      = lambda{|v| v.nil? ? nil : Time.parse(v).utc}
+  self.typecasts["decimal"]       = lambda{|v| BigDecimal(v)}
+  self.typecasts["double"]        = lambda{|v| v.nil? ? nil : v.to_f}
+  self.typecasts["float"]         = lambda{|v| v.nil? ? nil : v.to_f}
+  self.typecasts["symbol"]        = lambda{|v| v.to_sym}
+  self.typecasts["string"]        = lambda{|v| v.to_s}
+  self.typecasts["yaml"]          = lambda{|v| v.nil? ? nil : YAML.load(v)}
+  self.typecasts["base64Binary"]  = lambda{|v| v.unpack('m').first }
+
+  self.available_typecasts = self.typecasts.keys
+
+  def initialize(name, attributes = {})
+    @name         = name.tr("-", "_")
+    # leave the type alone if we don't know what it is
+    @type         = self.class.available_typecasts.include?(attributes["type"]) ? attributes.delete("type") : attributes["type"]
+
+    @nil_element  = attributes.delete("nil") == "true"
+    @attributes   = undasherize_keys(attributes)
+    @children     = []
+    @text         = false
+  end
+
+  def add_node(node)
+    @text = true if node.is_a? String
+    @children << node
+  end
+
+  def to_hash
+    if @type == "file"
+      f = StringIO.new((@children.first || '').unpack('m').first)
+      class << f
+        attr_accessor :original_filename, :content_type
+      end
+      f.original_filename = attributes['name'] || 'untitled'
+      f.content_type = attributes['content_type'] || 'application/octet-stream'
+      return {name => f}
+    end
+
+    if @text
+      return { name => typecast_value( translate_xml_entities( inner_html ) ) }
+    else
+      #change repeating groups into an array
+      groups = @children.inject({}) { |s,e| (s[e.name] ||= []) << e; s }
+
+      out = nil
+      if @type == "array"
+        out = []
+        groups.each do |k, v|
+          if v.size == 1
+            out << v.first.to_hash.entries.first.last
+          else
+            out << v.map{|e| e.to_hash[k]}
+          end
+        end
+        out = out.flatten
+
+      else # If Hash
+        out = {}
+        groups.each do |k,v|
+          if v.size == 1
+            out.merge!(v.first)
+          else
+            out.merge!( k => v.map{|e| e.to_hash[k]})
+          end
+        end
+        out.merge! attributes unless attributes.empty?
+        out = out.empty? ? nil : out
+      end
+
+      if @type && out.nil?
+        { name => typecast_value(out) }
+      else
+        { name => out }
+      end
+    end
+  end
+
+  # Typecasts a value based upon its type. For instance, if
+  # +node+ has #type == "integer",
+  # {{[node.typecast_value("12") #=> 12]}}
+  #
+  # @param value<String> The value that is being typecast.
+  #
+  # @details [:type options]
+  #   "integer"::
+  #     converts +value+ to an integer with #to_i
+  #   "boolean"::
+  #     checks whether +value+, after removing spaces, is the literal
+  #     "true"
+  #   "datetime"::
+  #     Parses +value+ using Time.parse, and returns a UTC Time
+  #   "date"::
+  #     Parses +value+ using Date.parse
+  #
+  # @return <Integer, TrueClass, FalseClass, Time, Date, Object>
+  #   The result of typecasting +value+.
+  #
+  # @note
+  #   If +self+ does not have a "type" key, or if it's not one of the
+  #   options specified above, the raw +value+ will be returned.
+  def typecast_value(value)
+    return value unless @type
+    proc = self.class.typecasts[@type]
+    proc.nil? ? value : proc.call(value)
+  end
+
+  # Convert basic XML entities into their literal values.
+  #
+  # @param value<#gsub> An XML fragment.
+  #
+  # @return <#gsub> The XML fragment after converting entities.
+  def translate_xml_entities(value)
+    value.gsub(/&lt;/,   "<").
+          gsub(/&gt;/,   ">").
+          gsub(/&quot;/, '"').
+          gsub(/&apos;/, "'").
+          gsub(/&amp;/,  "&")
+  end
+
+  # Take keys of the form foo-bar and convert them to foo_bar
+  def undasherize_keys(params)
+    params.keys.each do |key, value|
+      params[key.tr("-", "_")] = params.delete(key)
+    end
+    params
+  end
+
+  # Get the inner_html of the REXML node.
+  def inner_html
+    @children.join
+  end
+
+  # Converts the node into a readable HTML node.
+  #
+  # @return <String> The HTML node in text form.
+  def to_html
+    attributes.merge!(:type => @type ) if @type
+    "<#{name}#{attributes.to_xml_attributes}>#{@nil_element ? '' : inner_html}</#{name}>"
+  end
+
+  # @alias #to_html #to_s
+  def to_s
+    to_html
+  end
+end
+
+class ToHashParser
+  def self.from_xml(xml)
+    stack = []
+    parser = REXML::Parsers::BaseParser.new(xml)
+
+    while true
+      event = parser.pull
+      case event[0]
+      when :end_document
+        break
+      when :end_doctype, :start_doctype
+        # do nothing
+      when :start_element
+        stack.push REXMLUtilityNode.new(event[1], event[2])
+      when :end_element
+        if stack.size > 1
+          temp = stack.pop
+          stack.last.add_node(temp)
+        end
+      when :text, :cdata
+        stack.last.add_node(event[1]) unless event[1].strip.length == 0
+      end
+    end
+    stack.pop.to_hash
+  end
+end
+
+class Hash  
+  # @return <String> This hash as a query string
+  #
+  # @example
+  #   { :name => "Bob",
+  #     :address => {
+  #       :street => '111 Ruby Ave.',
+  #       :city => 'Ruby Central',
+  #       :phones => ['111-111-1111', '222-222-2222']
+  #     }
+  #   }.to_params
+  #     #=> "name=Bob&address[city]=Ruby Central&address[phones][]=111-111-1111&address[phones][]=222-222-2222&address[street]=111 Ruby Ave."
+  def to_params
+    params = self.map { |k,v| normalize_param(k,v) }.join
+    params.chop! # trailing &
+    params
+  end
+
+  # @param key<Object> The key for the param.
+  # @param value<Object> The value for the param.
+  #
+  # @return <String> This key value pair as a param
+  #
+  # @example normalize_param(:name, "Bob") #=> "name=Bob&"
+  def normalize_param(key, value)
+    param = ''
+    stack = []
+
+    if value.is_a?(Array)
+      param << value.map { |element| normalize_param("#{key}[]", element) }.join
+    elsif value.is_a?(Hash)
+      stack << [key,value]
+    else
+      param << "#{key}=#{URI.encode(value.to_s)}&"
+    end
+
+    stack.each do |parent, hash|
+      hash.each do |key, value|
+        if value.is_a?(Hash)
+          stack << ["#{parent}[#{key}]", value]
+        else
+          param << normalize_param("#{parent}[#{key}]", value)
+        end
+      end
+    end
+
+    param
+  end
+  
+  # @return <String> The hash as attributes for an XML tag.
+  #
+  # @example
+  #   { :one => 1, "two"=>"TWO" }.to_xml_attributes
+  #     #=> 'one="1" two="TWO"'
+  def to_xml_attributes
+    map do |k,v|
+      %{#{k.to_s.snake_case.sub(/^(.{1,1})/) { |m| m.downcase }}="#{v}"}
+    end.join(' ')
+  end
+end

data/lib/httparty/exceptions.rb

@@ -0,0 +1,4 @@
+module HTTParty
+  class UnsupportedFormat < StandardError; end
+  class RedirectionTooDeep < StandardError; end
+end

data/lib/httparty/request.rb

@@ -1,28 +1,35 @@
+require 'uri'
+
 module HTTParty
   class Request
     SupportedHTTPMethods = [Net::HTTP::Get, Net::HTTP::Post, Net::HTTP::Put, Net::HTTP::Delete]
 
     attr_accessor :http_method, :path, :options
-    
-    def initialize(http_method, path, options={})
+
+    def initialize(http_method, path, o={})
       self.http_method = http_method
       self.path = path
       self.options = {
-        :limit => options.delete(:no_follow) ? 0 : 5, 
+        :limit => o.delete(:no_follow) ? 0 : 5,
         :default_params => {},
-      }.merge(options.dup)
+        :keep_body => false
+      }.merge(o)
     end
 
     def path=(uri)
       @path = URI.parse(uri)
     end
-    
+
     def uri
       uri = path.relative? ? URI.parse("#{options[:base_uri]}#{path}") : path
       uri.query = query_string(uri)
       uri
     end
-    
+
+    def format
+      options[:format]
+    end
+
     def perform
       validate!
       handle_response!(get_response(uri))
@@ -35,36 +42,48 @@ module HTTParty
         http.verify_mode = OpenSSL::SSL::VERIFY_NONE
         http
       end
-      
+
       def get_response(uri) #:nodoc:
         request = http_method.new(uri.request_uri)
-        request.body = options[:body].is_a?(Hash) ? options[:body].to_query : options[:body] unless options[:body].blank?
+
+        if post? && options[:query]
+          request.set_form_data(options[:query])
+        end
+
+        request.body = options[:body].is_a?(Hash) ? options[:body].to_params : options[:body] unless options[:body].blank?
         request.initialize_http_header options[:headers]
-        request.basic_auth(options[:basic_auth][:username], options[:basic_auth][:password]) if options[:basic_auth]
+
+        if options[:basic_auth]
+          request.basic_auth(options[:basic_auth][:username], options[:basic_auth][:password])
+        end
+
         response = http(uri).request(request)
         options[:format] ||= format_from_mimetype(response['content-type'])
         response
       end
-      
+
       def query_string(uri) #:nodoc:
         query_string_parts = []
         query_string_parts << uri.query unless uri.query.blank?
 
         if options[:query].is_a?(Hash)
-          query_string_parts << options[:default_params].merge(options[:query]).to_query
+          query_string_parts << options[:default_params].merge(options[:query]).to_params
         else
-          query_string_parts << options[:default_params].to_query unless options[:default_params].blank?
+          query_string_parts << options[:default_params].to_params unless options[:default_params].blank?
           query_string_parts << options[:query] unless options[:query].blank?
         end
-        
+
         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) #:nodoc:
         case response
         when Net::HTTPSuccess
-          parse_response(response.body)
+          original_resp = parse_response(response.body)
+          final_resp = Response.new(response.body, nil, original_resp)
+          response.each_header { |n,v| final_resp.add_header(n, v) }
+          final_resp
         when Net::HTTPRedirection
           options[:limit] -= 1
           self.path = response['location']
@@ -75,30 +94,61 @@ module HTTParty
           response.error! # raises  exception corresponding to http error Net::XXX
         end
       end
-      
+
       def parse_response(body) #:nodoc:
         return nil if body.nil? or body.empty?
-        case options[:format]
-        when :xml
-          Hash.from_xml(body)
-        when :json
-          ActiveSupport::JSON.decode(body)
-        else
-          body
-        end
+        response = case format
+                   when :xml
+                     ToHashParser.from_xml(body)
+                   when :json
+                     JSON.parse(body)
+                   else
+                     body
+                   end
+        response
       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) #:nodoc:
+        return nil if mimetype.nil?
         AllowedFormats.each { |k, v| return k if mimetype.include?(v) }
       end
-      
+
       def validate! #:nodoc:
         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
+
+  class Response
+    attr_accessor :original_body, :format, :headers
+
+    def initialize(original_body, format, delegate)
+      self.original_body = original_body
+      self.format = format
+      self.headers = { }
+      @delegate = delegate
+    end
+
+    def add_header(name, value)
+      @headers[name] = value
+    end
+
+    def method_missing(sym, *args)
+      @delegate.send(sym, *args)
+    end
+
+    def pretty_print(pp)
+      @delegate.pretty_print(pp)
+    end
+
   end
 end

data/lib/httparty/version.rb

@@ -1,9 +1,3 @@
 module HTTParty
-  module VERSION #:nodoc:
-    MAJOR = 0
-    MINOR = 1
-    TINY  = 5
-
-    STRING = [MAJOR, MINOR, TINY].join('.')
-  end
+  Version = '0.2.6'
 end

data/lib/httparty.rb

@@ -1,37 +1,29 @@
+$:.unshift(File.dirname(__FILE__))
+
 require 'net/http'
 require 'net/https'
-require 'uri'
-require 'ostruct'
 require 'rubygems'
-require 'active_support'
-
-directory = File.dirname(__FILE__)
-$:.unshift(directory) unless $:.include?(directory) || $:.include?(File.expand_path(directory))
-
-require 'httparty/request'
+gem 'json', '>= 1.1.3'
+require 'json'
 
-module HTTParty
-  class UnsupportedFormat < StandardError; end
-  class RedirectionTooDeep < StandardError; end
+require 'module_level_inheritable_attributes'
+require 'core_extensions'
 
+module HTTParty  
   AllowedFormats = {:xml => 'text/xml', :json => 'application/json', :html => 'text/html'}
-
+  
   def self.included(base)
     base.extend ClassMethods
+    base.send :include, ModuleLevelInheritableAttributes
+    base.send(:mattr_inheritable, :default_options)
+    base.instance_variable_set("@default_options", {})
   end
-
+  
   module ClassMethods
     def default_options
-      @@default_options ||= {}
+      @default_options
     end
 
-    #
-    # Set an http proxy
-    #
-    # class Twitter
-    #   include HTTParty
-    #   http_proxy 'http://myProxy', 1080
-    # ....
     def http_proxy(addr=nil, port = nil)
       default_options[:http_proxyaddr] = addr
       default_options[:http_proxyport] = port
@@ -39,13 +31,13 @@ module HTTParty
 
     def base_uri(uri=nil)
       return default_options[:base_uri] unless uri
-      default_options[:base_uri] = normalize_base_uri(uri)
+      default_options[:base_uri] = HTTParty.normalize_base_uri(uri)
     end
 
     def basic_auth(u, p)
       default_options[:basic_auth] = {:username => u, :password => p}
     end
-
+    
     def default_params(h={})
       raise ArgumentError, 'Default params must be a hash' unless h.is_a?(Hash)
       default_options[:default_params] ||= {}
@@ -57,12 +49,12 @@ module HTTParty
       default_options[:headers] ||= {}
       default_options[:headers].merge!(h)
     end
-
+    
     def format(f)
       raise UnsupportedFormat, "Must be one of: #{AllowedFormats.keys.join(', ')}" unless AllowedFormats.key?(f)
       default_options[:format] = f
     end
-
+    
     def get(path, options={})
       perform_request Net::HTTP::Get, path, options
     end
@@ -81,27 +73,40 @@ module HTTParty
 
     private
       def perform_request(http_method, path, options) #:nodoc:
-        Request.new(http_method, path, default_options.merge(options)).perform
+        Request.new(http_method, path, default_options.dup.merge(options)).perform
       end
+  end
 
-      # Makes it so uri is sure to parse stuff like google.com without the http
-      def normalize_base_uri(url) #:nodoc:
-        use_ssl = (url =~ /^https/) || url.include?(':443')
-        url.chop! if url.ends_with?('/')
-        url.gsub!(/^https?:\/\//i, '')
-        "http#{'s' if use_ssl}://#{url}"
-      end
+  def self.normalize_base_uri(url) #:nodoc:
+    use_ssl = (url =~ /^https/) || url.include?(':443')
+    ends_with_slash = url =~ /\/$/
+    
+    url.chop! if ends_with_slash
+    url.gsub!(/^https?:\/\//i, '')
+    
+    "http#{'s' if use_ssl}://#{url}"
+  end
+  
+  class Basement
+    include HTTParty
+  end
+  
+  def self.get(*args)
+    Basement.get(*args)
+  end
+  
+  def self.post(*args)
+    Basement.post(*args)
+  end
 
-      # Figure out the Content-Type from the path extension
-      def format_from_path(path) #:nodoc:
-        case path
-        when /\.xml$/
-          'xml'
-        when /\.json$/
-          'json'
-        else
-          nil
-        end
-      end
+  def self.put(*args)
+    Basement.put(*args)
+  end
+
+  def self.delete(*args)
+    Basement.delete(*args)
   end
 end
+
+require 'httparty/exceptions'
+require 'httparty/request'

data/lib/module_level_inheritable_attributes.rb

@@ -0,0 +1,25 @@
+module ModuleLevelInheritableAttributes
+  def self.included(base)
+    base.extend(ClassMethods)
+  end
+  
+  module ClassMethods
+    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