alexvollmer-httparty 0.1.5

data/History.txt

@@ -0,0 +1,32 @@
+== 0.1.5 2008-11-14
+* 2 major enhancements
+  * Refactored send request method out into its own object.
+  * Added :html format if you just want to do that.
+  
+== 0.1.4 2008-11-08
+* 3 major enhancements:
+  * Removed some cruft
+  * Added ability to follow redirects automatically and turn that off (Alex Vollmer)
+
+== 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/google.rb
+examples/twitter.rb
+examples/whoismyrep.rb
+httparty.gemspec
+lib/httparty.rb
+lib/httparty/request.rb
+lib/httparty/version.rb
+script/console
+script/destroy
+script/generate
+script/txt2html
+setup.rb
+spec/httparty/request_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,66 @@
+= 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!")
+
+=== REQUEST OPTIONS
+
+Each of the HTTP method (get, post, put and delete) each take a hash of options.
+The following keys can be specified in the options:
+
+headers::       A <tt>Hash</tt> of header key/value pairs
+query::         A <tt>Hash</tt> of query key/value pairs
+body::          The body of the request. If it's a <tt>Hash</tt>, it is
+                converted into query-string format, otherwise it is sent
+                as-is.
+basic_auth::    A <tt>Hash</tt> containing keys for <tt>:username</tt> and
+                <tt>:password</tt>.
+no_follow::     Turns off automatic redirect following
+
+== REQUIREMENTS:
+
+* Active Support >= 2.1
+
+== INSTALL:
+
+* sudo gem install httparty

data/Rakefile

@@ -0,0 +1,11 @@
+require 'config/requirements'
+require 'config/hoe' # setup Hoe + all gem configuration
+require "spec/rake/spectask"
+
+Dir['tasks/**/*.rake'].each { |rake| load rake }
+
+task :default => :spec
+
+Spec::Rake::SpecTask.new do |t|
+  t.spec_files = FileList["spec/**/*_spec.rb"]
+end

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/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/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,38 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{httparty}
+  s.version = "0.1.5"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["John Nunemaker"]
+  s.date = %q{2008-11-14}
+  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/google.rb", "examples/twitter.rb", "examples/whoismyrep.rb", "httparty.gemspec", "lib/httparty.rb", "lib/httparty/request.rb", "lib/httparty/version.rb", "script/console", "script/destroy", "script/generate", "script/txt2html", "setup.rb", "spec/httparty/request_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.3.1}
+  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 Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<activesupport>, [">= 2.1"])
+      s.add_development_dependency(%q<hoe>, [">= 1.8.0"])
+    else
+      s.add_dependency(%q<activesupport>, [">= 2.1"])
+      s.add_dependency(%q<hoe>, [">= 1.8.0"])
+    end
+  else
+    s.add_dependency(%q<activesupport>, [">= 2.1"])
+    s.add_dependency(%q<hoe>, [">= 1.8.0"])
+  end
+end

data/lib/httparty/request.rb

@@ -0,0 +1,104 @@
+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={})
+      self.http_method = http_method
+      self.path = path
+      self.options = {
+        :limit => options.delete(:no_follow) ? 0 : 5, 
+        :default_params => {},
+      }.merge(options.dup)
+    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 perform
+      validate!
+      handle_response!(get_response(uri))
+    end
+
+    private
+      def http(uri) #:nodoc:
+        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
+        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?
+        request.initialize_http_header options[:headers]
+        request.basic_auth(options[:basic_auth][:username], options[:basic_auth][:password]) if options[:basic_auth]
+        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
+        else
+          query_string_parts << options[:default_params].to_query 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)
+        when Net::HTTPRedirection
+          options[:limit] -= 1
+          self.path = response['location']
+          perform
+        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:
+        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
+      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
+      
+      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)
+      end
+  end
+end

data/lib/httparty/version.rb

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

data/lib/httparty.rb

@@ -0,0 +1,107 @@
+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'
+
+module HTTParty
+  class UnsupportedFormat < StandardError; end
+  class RedirectionTooDeep < StandardError; end
+
+  AllowedFormats = {:xml => 'text/xml', :json => 'application/json', :html => 'text/html'}
+
+  def self.included(base)
+    base.extend ClassMethods
+  end
+
+  module ClassMethods
+    def 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
+    end
+
+    def base_uri(uri=nil)
+      return default_options[:base_uri] unless uri
+      default_options[:base_uri] = 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] ||= {}
+      default_options[:default_params].merge!(h)
+    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 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
+
+    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
+
+    private
+      def perform_request(http_method, path, options) #:nodoc:
+        Request.new(http_method, path, default_options.merge(options)).perform
+      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
+
+      # 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
+  end
+end

data/script/console

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+# File: script/console
+irb = RUBY_PLATFORM =~ /(:?mswin|mingw)/ ? 'irb.bat' : 'irb'
+
+libs =  " -r irb/completion"
+# Perhaps use a console_lib to store any extra methods I may want available in the cosole
+# libs << " -r #{File.dirname(__FILE__) + '/../lib/console_lib/console_logger.rb'}"
+libs <<  " -r #{File.dirname(__FILE__) + '/../lib/httparty.rb'}"
+puts "Loading httparty gem"
+exec "#{irb} #{libs} --simple-prompt"

data/script/destroy

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+APP_ROOT = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+
+begin
+  require 'rubigen'
+rescue LoadError
+  require 'rubygems'
+  require 'rubigen'
+end
+require 'rubigen/scripts/destroy'
+
+ARGV.shift if ['--help', '-h'].include?(ARGV[0])
+RubiGen::Base.use_component_sources! [:rubygems, :newgem, :newgem_theme, :test_unit]
+RubiGen::Scripts::Destroy.new.run(ARGV)