francxk-httparty 0.1.3

data/History.txt

@@ -0,0 +1,23 @@
+
+== 0.1.3 2008-08-22
+
+* 3 major enhancements:
+	* Added http_proxy key for setting proxy server and port (francxk@gmail.com)
+	* Now raises exception when http error occurs (francxk@gmail.com)
+	* Changed auto format detection from file extension to response content type (Jay Pignata)
+
+== 0.1.2 2008-08-09
+
+* 1 major enhancement:
+	* default_params were not being appended to query string if option[:query] was blank
+
+== 0.1.1 2008-07-30
+
+* 2 major enhancement:
+	* Added :basic_auth key for options when making a request
+	* :query and :body both now work with query string or hash
+
+== 0.1.0 2008-07-27
+
+* 1 major enhancement:
+  * Initial release

data/License.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2008 John Nunemaker
+
+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.

data/Manifest.txt

@@ -0,0 +1,31 @@
+History.txt
+License.txt
+Manifest.txt
+PostInstall.txt
+README.txt
+Rakefile
+config/hoe.rb
+config/requirements.rb
+examples/aaws.rb
+examples/delicious.rb
+examples/twitter.rb
+examples/whoismyrep.rb
+httparty.gemspec
+lib/httparty.rb
+lib/httparty/core_ext.rb
+lib/httparty/core_ext/hash.rb
+lib/httparty/version.rb
+script/console
+script/destroy
+script/generate
+script/txt2html
+setup.rb
+spec/hash_spec.rb
+spec/httparty_spec.rb
+spec/spec.opts
+spec/spec_helper.rb
+tasks/deployment.rake
+tasks/environment.rake
+tasks/website.rake
+website/css/common.css
+website/index.html

data/PostInstall.txt

@@ -0,0 +1 @@
+When you HTTParty, you must party hard!

data/README.txt

@@ -0,0 +1,52 @@
+= httparty
+
+== DESCRIPTION:
+
+Makes http fun again!
+
+== FEATURES/PROBLEMS:
+
+* Easy get, post, put, delete requests
+* Basic http authentication
+* Default request query string parameters (ie: for api keys that are needed on each request)
+* Automatic parsing of JSON and XML into ruby hashes based on response content-type
+
+== SYNOPSIS:
+
+The following is a simple example of wrapping Twitter's API for posting updates.
+
+	class Twitter
+	  include HTTParty
+	  base_uri 'twitter.com'
+	  basic_auth 'username', 'password'
+	end
+
+	Twitter.post('/statuses/update.json', :query => {:status => "It's an HTTParty and everyone is invited!"})
+
+That is really it! The object returned is a ruby hash that is decoded from Twitter's json response. JSON parsing is used because of the .json extension in the path of the request. You can also explicitly set a format (see the examples). 
+
+That works and all but what if you don't want to embed your username and password in the class? Below is an example to fix that:
+
+	class Twitter
+	  include HTTParty
+	  base_uri 'twitter.com'
+
+	  def initialize(u, p)
+	    @auth = {:username => u, :password => p}
+	  end
+
+	  def post(text)
+	    options = { :query => {:status => text}, :basic_auth => @auth }
+	    self.class.post('/statuses/update.json', options)
+	  end
+	end
+	
+	Twitter.new('username', 'password').post("It's an HTTParty and everyone is invited!")
+
+== REQUIREMENTS:
+
+* Active Support >= 2.1
+
+== INSTALL:
+
+* sudo gem install httparty

data/Rakefile

@@ -0,0 +1,4 @@
+require 'config/requirements'
+require 'config/hoe' # setup Hoe + all gem configuration
+
+Dir['tasks/**/*.rake'].each { |rake| load rake }

data/config/hoe.rb

@@ -0,0 +1,73 @@
+require 'httparty/version'
+
+AUTHOR = 'John Nunemaker'  # can also be an array of Authors
+EMAIL = "nunemaker@gmail.com"
+DESCRIPTION = "Makes http fun! Also, makes consuming restful web services dead easy."
+GEM_NAME = 'httparty' # what ppl will type to install your gem
+RUBYFORGE_PROJECT = 'httparty' # The unix name for your project
+HOMEPATH = "http://#{RUBYFORGE_PROJECT}.rubyforge.org"
+DOWNLOAD_PATH = "http://rubyforge.org/projects/#{RUBYFORGE_PROJECT}"
+EXTRA_DEPENDENCIES = [
+  ['activesupport', '>= 2.1']
+]    # An array of rubygem dependencies [name, version]
+
+@config_file = "~/.rubyforge/user-config.yml"
+@config = nil
+RUBYFORGE_USERNAME = "unknown"
+def rubyforge_username
+  unless @config
+    begin
+      @config = YAML.load(File.read(File.expand_path(@config_file)))
+    rescue
+      puts <<-EOS
+ERROR: No rubyforge config file found: #{@config_file}
+Run 'rubyforge setup' to prepare your env for access to Rubyforge
+ - See http://newgem.rubyforge.org/rubyforge.html for more details
+      EOS
+      exit
+    end
+  end
+  RUBYFORGE_USERNAME.replace @config["username"]
+end
+
+
+REV = nil
+# UNCOMMENT IF REQUIRED:
+# REV = YAML.load(`svn info`)['Revision']
+VERS = HTTParty::VERSION::STRING + (REV ? ".#{REV}" : "")
+RDOC_OPTS = ['--quiet', '--title', 'httparty documentation',
+    "--opname", "index.html",
+    "--line-numbers",
+    "--main", "README",
+    "--inline-source"]
+
+class Hoe
+  def extra_deps
+    @extra_deps.reject! { |x| Array(x).first == 'hoe' }
+    @extra_deps
+  end
+end
+
+# Generate all the Rake tasks
+# Run 'rake -T' to see list of generated tasks (from gem root directory)
+$hoe = Hoe.new(GEM_NAME, VERS) do |p|
+  p.developer(AUTHOR, EMAIL)
+  p.description = DESCRIPTION
+  p.summary = DESCRIPTION
+  p.url = HOMEPATH
+  p.rubyforge_name = RUBYFORGE_PROJECT if RUBYFORGE_PROJECT
+  p.test_globs = ["test/**/test_*.rb"]
+  p.clean_globs |= ['**/.*.sw?', '*.gem', '.config', '**/.DS_Store']  #An array of file patterns to delete on clean.
+
+  # == Optional
+  p.changes = p.paragraphs_of("History.txt", 0..1).join("\n\n")
+  p.extra_deps = EXTRA_DEPENDENCIES
+
+    #p.spec_extras = {}    # A hash of extra values to set in the gemspec.
+  end
+
+CHANGES = $hoe.paragraphs_of('History.txt', 0..1).join("\\n\\n")
+PATH    = (RUBYFORGE_PROJECT == GEM_NAME) ? RUBYFORGE_PROJECT : "#{RUBYFORGE_PROJECT}/#{GEM_NAME}"
+$hoe.remote_rdoc_dir = File.join(PATH.gsub(/^#{RUBYFORGE_PROJECT}\/?/,''), 'rdoc')
+$hoe.rsync_args = '-av --delete --ignore-errors'
+$hoe.spec.post_install_message = File.open(File.dirname(__FILE__) + "/../PostInstall.txt").read rescue ""

data/config/requirements.rb

@@ -0,0 +1,15 @@
+require 'fileutils'
+include FileUtils
+
+require 'rubygems'
+%w[rake hoe newgem rubigen].each do |req_gem|
+  begin
+    require req_gem
+  rescue LoadError
+    puts "This Rakefile requires the '#{req_gem}' RubyGem."
+    puts "Installation: gem install #{req_gem} -y"
+    exit
+  end
+end
+
+$:.unshift(File.join(File.dirname(__FILE__), %w[.. lib]))

data/examples/aaws.rb

@@ -0,0 +1,29 @@
+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'], '.aaws')))
+
+module AAWS
+  class Book
+    include HTTParty
+    base_uri 'http://ecs.amazonaws.com'
+    default_params :Service => 'AWSECommerceService', :Operation => 'ItemSearch', :SearchIndex => 'Books'
+    
+    def initialize(key)
+      self.class.default_params :AWSAccessKeyId => key
+    end
+    
+    def search(options={})
+      raise ArgumentError, 'You must search for something' if options[:query].blank?
+      
+      # amazon uses nasty camelized query params
+      options[:query] = options[:query].inject({}) { |h, q| h[q[0].to_s.camelize] = q[1]; h }
+      
+      # make a request and return the items (NOTE: this doesn't handle errors at this point)
+      self.class.get('/onca/xml', options)['ItemSearchResponse']['Items']
+    end
+  end
+end
+
+aaws = AAWS::Book.new(config[:access_key])
+pp aaws.search(:query => {:title => 'Ruby On Rails'})

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})
+    # get posts and convert to structs so we can do .key instead of ['key'] with results
+    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
+

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')

data/examples/whoismyrep.rb

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

data/httparty.gemspec

@@ -0,0 +1,33 @@
+Gem::Specification.new do |s|
+  s.name = %q{httparty}
+  s.version = "0.1.3"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["John Nunemaker"]
+  s.date = %q{2008-08-22}
+  s.description = %q{Makes http fun! Also, makes consuming restful web services dead easy.}
+  s.email = ["nunemaker@gmail.com"]
+  s.extra_rdoc_files = ["History.txt", "License.txt", "Manifest.txt", "PostInstall.txt", "README.txt"]
+  s.files = ["History.txt", "License.txt", "Manifest.txt", "PostInstall.txt", "README.txt", "Rakefile", "config/hoe.rb", "config/requirements.rb", "examples/aaws.rb", "examples/delicious.rb", "examples/twitter.rb", "examples/whoismyrep.rb", "httparty.gemspec", "lib/httparty.rb", "lib/httparty/core_ext.rb", "lib/httparty/core_ext/hash.rb", "lib/httparty/version.rb", "script/console", "script/destroy", "script/generate", "script/txt2html", "setup.rb", "spec/hash_spec.rb", "spec/httparty_spec.rb", "spec/spec.opts", "spec/spec_helper.rb", "tasks/deployment.rake", "tasks/environment.rake", "tasks/website.rake", "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 = ["--main", "README.txt"]
+  s.require_paths = ["lib"]
+  s.rubyforge_project = %q{httparty}
+  s.rubygems_version = %q{1.2.0}
+  s.summary = %q{Makes http fun! Also, makes consuming restful web services dead easy.}
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 2
+
+    if current_version >= 3 then
+      s.add_runtime_dependency(%q<activesupport>, [">= 2.1"])
+    else
+      s.add_dependency(%q<activesupport>, [">= 2.1"])
+    end
+  else
+    s.add_dependency(%q<activesupport>, [">= 2.1"])
+  end
+end

data/lib/httparty.rb

@@ -0,0 +1,165 @@
+require 'net/http'
+require 'net/https'
+require 'uri'
+require 'ostruct'
+require 'rubygems'
+require 'active_support'
+
+$:.unshift(File.dirname(__FILE__)) unless
+  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+dir = File.expand_path(File.join(File.dirname(__FILE__), 'httparty'))
+require dir + '/core_ext'
+  
+module HTTParty
+  class UnsupportedFormat < StandardError; end
+
+  def self.included(base)
+    base.extend ClassMethods
+  end
+
+  AllowedFormats = {:xml => 'text/xml', :json => 'application/json'}
+
+  module ClassMethods    
+    #
+    # Set an http proxy
+    #
+    #	class Twitter
+    #	  include HTTParty
+    #	  http_proxy http://myProxy, 1080
+    # ....
+    def http_proxy(addr=nil, port = nil)
+	   @http_proxyaddr = addr
+	   @http_proxyport = port
+    end
+
+    def base_uri(base_uri=nil)
+      return @base_uri unless base_uri
+      # don't want this to ever end with /
+      base_uri = base_uri.ends_with?('/') ? base_uri.chop : base_uri
+      @base_uri = normalize_base_uri(base_uri)
+    end
+    
+    # Warning: This is not thread safe most likely and
+    # only works if you use one set of credentials. I
+    # leave it because it is convenient on some occasions.
+    def basic_auth(u, p)
+      @auth = {:username => u, :password => p}
+    end
+    
+    # Updates the default query string parameters
+    # that should be appended to each request.
+    def default_params(h={})
+      raise ArgumentError, 'Default params must be a hash' unless h.is_a?(Hash)
+      @default_params ||= {}
+      return @default_params if h.blank?
+      @default_params.merge!(h)
+    end
+
+    def headers(h={})
+      raise ArgumentError, 'Headers must be a hash' unless h.is_a?(Hash)
+      @headers ||= {}
+      return @headers if h.blank?
+      @headers.merge!(h)
+    end
+    
+    def format(f)
+      raise UnsupportedFormat, "Must be one of: #{AllowedFormats.keys.join(', ')}" unless AllowedFormats.key?(f)
+      @format = f
+    end
+    
+    # TODO: spec out this
+    def get(path, options={})
+      send_request 'get', path, options
+    end
+
+    # TODO: spec out this    
+    def post(path, options={})
+      send_request 'post', path, options
+    end
+
+    # TODO: spec out this    
+    def put(path, options={})
+      send_request 'put', path, options
+    end
+
+    # TODO: spec out this    
+    def delete(path, options={})
+      send_request 'delete', path, options
+    end
+    
+    private
+      def http(uri) #:nodoc:
+        if @http.blank?
+          @http = Net::HTTP.new(uri.host, uri.port, @http_proxyaddr, @http_proxyport)
+          @http.use_ssl = (uri.port == 443)
+          # so we can avoid ssl warnings
+          @http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+        end
+        @http
+      end
+      
+      # FIXME: this method is doing way to much and needs to be split up
+      # options can be any or all of:
+      #   query       => hash of keys/values or a query string (foo=bar&baz=poo)
+      #   body        => hash of keys/values or a query string (foo=bar&baz=poo)
+      #   headers     => hash of headers to send request with
+      #   basic_auth  => :username and :password to use as basic http authentication (overrides @auth class instance variable)
+      # Raises exception Net::XXX (http error code) if an http error occured
+      def send_request(method, path, options={}) #:nodoc:
+        raise ArgumentError, 'only get, post, put and delete methods are supported' unless %w[get post put delete].include?(method.to_s)
+        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)
+        uri            = URI.parse("#{base_uri}#{path}")
+        existing_query = uri.query ? "#{uri.query}&" : ''
+        uri.query      = if options[:query].blank?
+          existing_query + default_params.to_query
+        else
+          existing_query + (options[:query].is_a?(Hash) ? default_params.merge(options[:query]).to_query : options[:query])
+        end
+        klass          = Net::HTTP.const_get method.to_s.downcase.capitalize
+        request        = klass.new(uri.request_uri)
+        request.body   = options[:body].is_a?(Hash) ? options[:body].to_query : options[:body] unless options[:body].blank?
+        basic_auth     = options.delete(:basic_auth) || @auth
+        request.initialize_http_header headers.merge(options[:headers] || {})
+        # note to self: self, do not put basic auth above headers because it removes basic auth
+        request.basic_auth(basic_auth[:username], basic_auth[:password]) if basic_auth
+        response       = http(uri).request(request)
+
+        @format      ||= format_from_mimetype(response['content-type'])
+
+        case response
+        when Net::HTTPSuccess
+          parse_response(response.body)
+        else
+          response.instance_eval { class << self; attr_accessor :body_parsed; end }
+          begin; response.body_parsed = parse_response(response.body); rescue; end
+          response.error! # raises  exception corresponding to http error Net::XXX
+        end
+
+      end
+
+      def parse_response(body) #:nodoc:
+        case @format
+        when :xml
+          Hash.from_xml(body)
+        when :json
+          ActiveSupport::JSON.decode(body)
+        else
+          # just return the response if no format 
+          body
+        end
+      end
+    
+      # Makes it so uri is sure to parse stuff like google.com with the http
+      def normalize_base_uri(str) #:nodoc:
+        str =~ /^https?:\/\// ? str : "http#{'s' if str.include?(':443')}://#{str}"
+      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:
+        AllowedFormats.each { |k, v| return k if mimetype.include?(v) }
+      end
+  end
+end