jnunemaker-httparty 0.1.8 → 0.2.0

data/History

@@ -1,3 +1,7 @@
+== 0.2.0 2008-12-07
+* 1 major enhancement
+  * Removed ActiveSupport as a dependency. Now requires json gem for json deserialization and uses an included class to do the xml parsing.
+
 == 0.1.8 2008-11-30
 * 3 major enhancements
   * Moved base_uri normalization into request class and out of httparty module, fixing 

data/Manifest

@@ -6,15 +6,21 @@ examples/rubyurl.rb
 examples/twitter.rb
 examples/whoismyrep.rb
 History
-httparty.gemspec
+lib/core_extensions.rb
+lib/httparty/exceptions.rb
 lib/httparty/request.rb
 lib/httparty/version.rb
 lib/httparty.rb
+lib/module_level_inheritable_attributes.rb
 Manifest
 MIT-LICENSE
 Rakefile
 README
 setup.rb
+spec/fixtures/delicious.xml
+spec/fixtures/google.html
+spec/fixtures/twitter.json
+spec/fixtures/twitter.xml
 spec/httparty/request_spec.rb
 spec/httparty_spec.rb
 spec/spec.opts

data/Rakefile

@@ -13,7 +13,7 @@ Echoe.new(ProjectName, HTTParty::Version) do |p|
   p.url             = "http://#{ProjectName}.rubyforge.org"
   p.author          = "John Nunemaker"
   p.email           = "nunemaker@gmail.com"
-  p.extra_deps      = [['activesupport', '>= 2.1']]
+  p.extra_deps      = [['json', '~> 1.1']]
   p.need_tar_gz     = false
   p.docs_host       = WebsitePath
 end

data/examples/aaws.rb

@@ -1,3 +1,6 @@
+require 'rubygems'
+require 'activesupport'
+
 dir = File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib'))
 require File.join(dir, 'httparty')
 require 'pp'

data/examples/delicious.rb

@@ -18,7 +18,6 @@ class Delicious
   #   ie: posts(:query => {:tag => 'ruby'})
   def posts(options={})
     options.merge!({:basic_auth => @auth})
-    # get posts and convert to structs so we can do .key instead of ['key'] with results
     self.class.get('/posts/get', options)
   end
   
@@ -33,4 +32,5 @@ end
 
 delicious = Delicious.new(config['username'], config['password'])
 pp delicious.posts(:query => {:tag => 'ruby'})
+pp delicious.recent
 

data/examples/rubyurl.rb

@@ -1,14 +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)
-    xml = post('/api/links.json', :query => {'link[website_url]' => website_url})
-    xml['link'] && xml['link']['permalink']
+  def self.shorten( website_url )
+    post( '/api/links.json', :query => { :link => { :website_url => website_url } } )
   end
 end
 
-puts Rubyurl.shorten( 'http://istwitterdown.com/' ).inspect
+pp Rubyurl.shorten( 'http://istwitterdown.com/' )

data/examples/twitter.rb

@@ -28,4 +28,4 @@ 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')
+# pp twitter.post('this is a test of 0.2.0')

data/examples/whoismyrep.rb

@@ -6,4 +6,5 @@ class Rep
   include HTTParty
 end
 
-puts Rep.get('http://whoismyrepresentative.com/whoismyrep.php?zip=46544').inspect
+pp Rep.get('http://whoismyrepresentative.com/whoismyrep.php?zip=46544')
+pp Rep.get('http://whoismyrepresentative.com/whoismyrep.php', :query => {:zip => 46544})

data/httparty.gemspec

@@ -2,15 +2,15 @@
 
 Gem::Specification.new do |s|
   s.name = %q{httparty}
-  s.version = "0.1.8"
+  s.version = "0.2.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 1.2") if s.respond_to? :required_rubygems_version=
   s.authors = ["John Nunemaker"]
-  s.date = %q{2008-12-05}
+  s.date = %q{2008-12-07}
   s.description = %q{Makes http fun! Also, makes consuming restful web services dead easy.}
   s.email = %q{nunemaker@gmail.com}
-  s.extra_rdoc_files = ["lib/httparty/request.rb", "lib/httparty/version.rb", "lib/httparty.rb", "README"]
-  s.files = ["examples/aaws.rb", "examples/basic.rb", "examples/delicious.rb", "examples/google.rb", "examples/rubyurl.rb", "examples/twitter.rb", "examples/whoismyrep.rb", "History", "httparty.gemspec", "lib/httparty/request.rb", "lib/httparty/version.rb", "lib/httparty.rb", "Manifest", "MIT-LICENSE", "Rakefile", "README", "setup.rb", "spec/httparty/request_spec.rb", "spec/httparty_spec.rb", "spec/spec.opts", "spec/spec_helper.rb", "website/css/common.css", "website/index.html"]
+  s.extra_rdoc_files = ["lib/core_extensions.rb", "lib/httparty/exceptions.rb", "lib/httparty/request.rb", "lib/httparty/version.rb", "lib/httparty.rb", "lib/module_level_inheritable_attributes.rb", "README"]
+  s.files = ["examples/aaws.rb", "examples/basic.rb", "examples/delicious.rb", "examples/google.rb", "examples/rubyurl.rb", "examples/twitter.rb", "examples/whoismyrep.rb", "History", "httparty.gemspec", "lib/core_extensions.rb", "lib/httparty/exceptions.rb", "lib/httparty/request.rb", "lib/httparty/version.rb", "lib/httparty.rb", "lib/module_level_inheritable_attributes.rb", "Manifest", "MIT-LICENSE", "Rakefile", "README", "setup.rb", "spec/fixtures/delicious.xml", "spec/fixtures/google.html", "spec/fixtures/twitter.json", "spec/fixtures/twitter.xml", "spec/httparty/request_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!}
@@ -25,14 +25,14 @@ Gem::Specification.new do |s|
     s.specification_version = 2
 
     if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
-      s.add_runtime_dependency(%q<activesupport>, [">= 2.1"])
+      s.add_runtime_dependency(%q<json>, ["~> 1.1"])
       s.add_development_dependency(%q<echoe>, [">= 0"])
     else
-      s.add_dependency(%q<activesupport>, [">= 2.1"])
+      s.add_dependency(%q<json>, ["~> 1.1"])
       s.add_dependency(%q<echoe>, [">= 0"])
     end
   else
-    s.add_dependency(%q<activesupport>, [">= 2.1"])
+    s.add_dependency(%q<json>, ["~> 1.1"])
     s.add_dependency(%q<echoe>, [">= 0"])
   end
 end

data/lib/core_extensions.rb

@@ -0,0 +1,340 @@
+# 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
+    @@typecasts
+  end
+  
+  def self.available_typecasts=(obj)
+    @@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
+  def self.from_xml(xml)
+    ToHashParser.from_xml(xml)
+  end
+  
+  # @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
+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,24 +1,18 @@
+require 'uri'
+
 module HTTParty
-  class Request
-    # Makes it so uri is sure to parse stuff like google.com without the http
-    def self.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
-    
+  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)
+      }.merge(o)
     end
 
     def path=(uri)
@@ -26,12 +20,15 @@ module HTTParty
     end
     
     def uri
-      options[:base_uri] = self.class.normalize_base_uri(options[:base_uri]) unless options[:base_uri].nil?
       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))
@@ -47,10 +44,18 @@ module HTTParty
       
       def get_response(uri) #:nodoc:
         request = http_method.new(uri.request_uri)   
-        request.set_form_data(options[:query]) if post? && options[:query]
-        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
@@ -61,9 +66,9 @@ module HTTParty
         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
         
@@ -88,11 +93,11 @@ module HTTParty
       
       def parse_response(body) #:nodoc:
         return nil if body.nil? or body.empty?
-        case options[:format]
+        case format
         when :xml
           Hash.from_xml(body)
         when :json
-          ActiveSupport::JSON.decode(body)
+          JSON.parse(body)
         else
           body
         end

data/lib/httparty/version.rb

@@ -1,3 +1,3 @@
 module HTTParty
-  Version = '0.1.8'
+  Version = '0.2.0'
 end