resthome 0.6.0

data/.document

@@ -0,0 +1,5 @@
+lib/**/*.rb
+bin/*
+- 
+features/**/*.feature
+LICENSE.txt

data/Gemfile

@@ -0,0 +1,16 @@
+source "http://rubygems.org"
+# Add dependencies required to use your gem here.
+# Example:
+#   gem "activesupport", ">= 2.3.5"
+gem "httparty", ">= 0"
+
+# Add dependencies to develop your gem here.
+# Include everything needed to run rake, tests, features, etc.
+group :development do
+  gem "bundler", "~> 1.0.0"
+  gem "jeweler", "~> 1.5.1"
+  gem "rcov", ">= 0"
+  gem "fakeweb", ">= 0"
+  gem "json", ">= 0"
+  gem "rspec", ">= 0"
+end

data/Gemfile.lock

@@ -0,0 +1,28 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    crack (0.1.8)
+    fakeweb (1.2.8)
+    git (1.2.5)
+    httparty (0.6.1)
+      crack (= 0.1.8)
+    jeweler (1.5.1)
+      bundler (~> 1.0.0)
+      git (>= 1.2.5)
+      rake
+    json (1.2.4)
+    rake (0.8.7)
+    rcov (0.9.8)
+    rspec (1.3.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.0.0)
+  fakeweb
+  httparty
+  jeweler (~> 1.5.1)
+  json
+  rcov
+  rspec

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2010 Doug Youch
+
+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/README.rdoc

@@ -0,0 +1,80 @@
+= RESTHome
+
+Simple wrapper class generator for consuming RESTful web services
+
+== RESTful Example
+
+RESTHome's are used to communicate to RESTful Web Services.
+
+Let's say you are working with B2B.dev. They provide a simple RESTful API for interacting with customer data.
+
+API looks like
+ GET    http://api.b2b.dev/customers.json      - list of your customers
+ GET    http://api.b2b.dev/customers/<id>.json - customer data
+ PUT    http://api.b2b.dev/customers/<id>.json - edit customer data
+ DELETE http://api.b2b.dev/customers/<id>.json - delete customer
+ POST   http://api.b2b.dev/customers.json      - create a new customer
+
+ JSON response looks like {'customer': {'id': 99, 'first_name': 'Joe', 'last_name': 'Smith'}}
+
+Create a simple RESTHome service to interact with B2B.dev api.
+
+ class B2BService < RESTHome
+   rest :customer, :customers, '/customers.json'
+
+   def initialize(api_key)
+     self.base_uri = 'http://api.b2b.dev'
+     self.basic_auth = {:username => api_key, :password => 'x'}
+   end
+ end
+
+ service = B2BService.new 'XXXXX'
+ service.customers # returns an array of customers
+ customer = service.customer 99 # returns the data for customer 99, i.e. {:first_name => 'Joe', :last_name => 'Smith'}
+ service.edit_customer 99, :first_name => 'Joesph', :last_name => 'Smithie' # edits customer 99
+ service.delete_customer 99 # deletes customer 99
+ service.create_customer :first_name => 'John', :last_name => 'Doe' # creates a new customer
+
+== Lorem Lipsum Example
+
+Create a simple lorem lipsum generator, using http://www.lipsum.com.
+
+ lipsum = RESTHome.new
+ lipsum.base_uri = 'http://www.lipsum.com'
+ lipsum.route :generate, '/feed/json', :method => :post
+ words = lipsum.generate(:what => 'words', :amount => 20) do |res|
+   res['feed']['lipsum']
+ end
+
+
+ class LoremLipsumService < RESTHome
+   route :generate, '/feed/json', :method => :post, :return => :parse_feed
+
+   def initialize
+     self.base_uri = 'http://www.lipsum.com'
+   end
+
+   def parse_feed(res)
+     res['feed']['lipsum']
+   end
+ end
+
+ service = LoremLipsumService.new
+ words = service.generate(:what => 'words', :amount => 20)
+
+
+== Contributing to RESTHome
+ 
+* Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet
+* Check out the issue tracker to make sure someone already hasn't requested it and/or contributed it
+* Fork the project
+* Start a feature/bugfix branch
+* Commit and push until you are happy with your contribution
+* Make sure to add tests for it. This is important so I don't break it in a future version unintentionally.
+* Please try not to mess with the Rakefile, version, or history. If you want to have your own version, or is otherwise necessary, that is fine, but please isolate to its own commit so I can cherry-pick around it.
+
+== Copyright
+
+Copyright (c) 2010 Doug Youch. See LICENSE.txt for
+further details.
+

data/Rakefile

@@ -0,0 +1,50 @@
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.name = "resthome"
+  gem.homepage = "http://github.com/cykod/resthome"
+  gem.license = "MIT"
+  gem.summary = %Q{RESTful web services consumer}
+  gem.description = %Q{Simple wrapper class generator for consuming RESTful web services}
+  gem.email = "doug@cykod.com"
+  gem.authors = ["Doug Youch"]
+  # Include your dependencies below. Runtime dependencies are required when using your gem,
+  # and development dependencies are only needed for development (ie running rake tasks, tests, etc)
+  #  gem.add_runtime_dependency 'jabber4r', '> 0.1'
+  gem.add_runtime_dependency 'httparty', '>= 0'
+  #  gem.add_development_dependency 'rspec', '> 1.2.3'
+  gem.add_development_dependency "bundler", "~> 1.0.0"
+  gem.add_development_dependency "jeweler", "~> 1.5.1"
+  gem.add_development_dependency "rcov", ">= 0"
+  gem.add_development_dependency "fakeweb", ">= 0"
+  gem.add_development_dependency "json", ">= 0"
+  gem.add_development_dependency "rspec", ">= 0"
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+task :default => :spec
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "resthome #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+for file in Dir['tasks/*.rake']
+  load file
+end

data/VERSION

@@ -0,0 +1 @@
+0.6.0

data/examples/chargify_web_service.rb

@@ -0,0 +1,53 @@
+require 'resthome'
+require 'json'
+
+class ChargifyWebService < RESTHome
+
+  headers 'Content-Type' => 'application/json'
+
+  rest :customer, :customers, '/customers.json'
+  route :find_customer, '/customers/lookup.json', :resource => 'customer'
+  # find_customer_by_reference
+  route :customer_subscriptions, '/customers/:customer_id/subscriptions.json', :resource => :subscription
+
+  route :product_families, '/product_families.xml', :resource => :product_families
+
+  route :products, '/products.json', :resource => :product
+  route :product, '/products/:product_id.json', :resource => :product
+  route :find_product_by_handle, '/products/handle/:handle.json', :resource => :product
+
+  rest :subscription, :subscriptions, '/subscriptions.json'
+  route :cancel_subscription, '/subscriptions/:subscription_id.json', :resource => :subscription, :method => :delete, :expected_status => [200, 204]
+  route :reactivate_subscription, '/subscriptions/:subscription_id/reactivate.xml', :resource => :subscription, :method => :put, :expected_status => 200
+  route :subscription_transactions, '/subscriptions/:subscription_id/transactions.json', :resource => :transaction
+  # Chargify offers the ability to upgrade or downgrade a Customer's subscription in the middle of a billing period.
+  route :create_subscription_migration, '/subscriptions/:subscription_id/migrations.json', :expected_status => 200
+  route :reactivate_subscription, '/subscriptions/:subscription_id/reactivate.xml', :resource => :subscription, :method => :put, :expected_status => 200
+  route :create_subscription_credit, '/subscriptions/:subscription_id/credits.json', :resource => :credit
+  route :reset_subscription_balance, '/subscriptions/:subscription_id/reset_balance.xml', :resource => :subscription, :method => :put, :expected_status => 200
+
+  route :transactions, '/transactions.json', :resource => :transaction
+
+  route :create_charge, '/subscriptions/:subscription_id/charges.json', :resource => :charge
+
+  route :components, '/product_families/:product_family_id/components.json', :resource => :component
+  route :component_usages, '/subscriptions/:subscription_id/components/:component_id/usages.json', :resource => :usage
+  route :create_component_usage, '/subscriptions/:subscription_id/components/:component_id/usages.json', :resource => :usage, :expected_status => 200
+
+  route :coupon, '/product_families/:product_family_id/coupons/:coupon_id.json', :resource => :coupon
+  route :find_coupon, '/product_families/:product_family_id/coupons/find.json', :resource => :coupon
+  # find_coupon_by_code
+
+  route :subscription_components, '/subscriptions/:subscription_id/components.json', :resource => :component
+  route :edit_subscription_component, '/subscriptions/:subscription_id/components/:component_id.json', :resource => :component
+
+  def initialize(api_key, subdomain)
+    self.base_uri = "https://#{subdomain}.chargify.com"
+    self.basic_auth = {:username => api_key, :password => 'x'}
+  end
+
+  def build_options!(options)
+    super
+    options[:body] = options[:body].to_json if options[:body]
+  end
+end

data/examples/wordpress_web_service.rb

@@ -0,0 +1,89 @@
+require 'resthome'
+require 'nokogiri'
+
+class WordpressWebService < RESTHome
+  attr_accessor :error
+
+  headers 'User-Agent' => 'Mozilla/5.0 (Windows; U; Windows NT 6.1; ru; rv:1.9.2.3) Gecko/20100401 Firefox/4.0 (.NET CLR 3.5.30729)'
+
+  def initialize(url, username, password)
+    @uri = URI.parse(url.gsub(/\/$/, ''))
+    @username = username
+    @password = password
+    self.base_uri = "#{@uri.scheme}://#{@uri.host}:#{@uri.port}"
+
+    self.route :wp_login_get, "#{@uri.path}/wp-login.php", :method => :get, :return => :parse_login_page
+    self.route :wp_login_post, "#{@uri.path}/wp-login.php", :method => :post, :return => :parse_login_page
+
+    self.route :wp_export_get, "#{@uri.path}/wp-admin/export.php", :method => :get, :return => :parse_export_form
+    self.route :wp_export, "#{@uri.path}/wp-admin/export.php", :method => :get
+  end
+
+  def parse_login_page(response)
+    return @error = 'Login page not found' unless response.code == 200
+
+    parent = Nokogiri::HTML.parse(response.body).css('body').first
+    login_form = parent.css('#loginform')
+    return @error = 'Login form not found' unless login_form.size > 0
+
+    login_error = parent.css('#login_error')
+    return @error = 'Login failed' if login_error.size > 0
+
+    login_form = login_form.first
+    @inputs = {}
+    login_form.css('input').each do |input|
+      next unless input.attributes['name']
+      @inputs[input.attributes['name'].to_s] = (input.attributes['value'] || '').to_s
+    end
+  end
+
+  def login
+    self.wp_login_get
+    return false if @inputs.nil?
+    @inputs['log'] = @username
+    @inputs['pwd'] = @password
+    begin
+      self.wp_login_post @inputs, :no_follow => true
+    rescue HTTParty::RedirectionTooDeep => e
+      save_cookies e.response.header.to_hash['set-cookie']
+    end
+    @error ? false : true
+  end
+
+  def parse_export_form(response)
+    parent = Nokogiri::HTML.parse(response.body).css('body').first
+    forms = parent.css('form')
+    return @error = 'Export form not found' unless forms.size > 0
+    export_form = forms.shift
+    while export_form && export_form.css('#mm_start').length == 0
+      export_form = forms.shift
+    end
+    return @error = 'Export form not found' unless export_form
+
+    @inputs = {}
+    export_form.css('input').each do |input|
+      next unless input.attributes['name']
+      @inputs[input.attributes['name'].to_s] = (input.attributes['value'] || '').to_s
+    end
+
+    export_form.css('select').each do |input|
+      next unless input.attributes['name']
+      value = ''
+      input.css('option').each do |option|
+        value = option.attributes['value'] if option.attributes['selected']
+      end
+      
+      @inputs[input.attributes['name'].to_s] = (value || '').to_s
+    end
+
+    @inputs
+  end
+
+  def export
+    self.wp_export_get
+    return false if @error
+    self.wp_export :query => @inputs, :format => :plain
+    return self.response.body if self.response.headers['content-type'].to_s =~ /xml/
+    false
+  end
+end

data/lib/resthome.rb

@@ -0,0 +1,287 @@
+# Copyright (C) Doug Youch
+
+require 'httparty'
+
+class RESTHome
+  class Error < Exception; end
+  class InvalidResponse < Error; end
+  class MethodMissing < Error; end
+
+  include HTTParty
+
+  attr_accessor :base_uri, :basic_auth, :cookies
+  attr_reader :response, :request_url, :request_options, :request_method
+
+  # Defines a web service route
+  #
+  # === Arguments
+  # *name* of the method to create
+  # name has special meaning.
+  # * If starts with create or add the method will be set to POST.
+  # * If starts with edit or update the method will be set to PUT.
+  # * If starts with delete the method will be set to DELETE.
+  # * Else by default the method is GET.
+  #
+  # *path* is the path to the web service
+  #
+  # === Options
+  #
+  # [:method]
+  #   The request method get/post/put/delete. Default is get.
+  # [:expected_status]
+  #   Expected status code of the response, will raise InvalidResponse. Can be an array of codes.
+  # [:return]
+  #   The method to call or the class to create before method returns.
+  # [:resource]
+  #   The name of the element to return from the response.
+  # [:no_body]
+  #   Removes the body argument from a post/put route
+  def self.route(name, path, options={})
+    args = path.scan /:[a-z_]+/
+    function_args = args.collect{ |arg| arg[1..-1] }
+
+    method = options[:method]
+    expected_status = options[:expected_status]
+    if method.nil?
+      if name.to_s =~ /^(create|add|edit|update|delete)_/
+        case $1
+        when 'create'
+          method = 'post'
+          expected_status ||= [200, 201]
+        when 'add'
+          method = 'post'
+          expected_status ||= [200, 201]
+        when 'edit'
+          method = 'put'
+          expected_status ||= 200
+        when 'update'
+          method = 'put'
+          expected_status ||= 200
+        when 'delete'
+          method = 'delete'
+          expected_status ||= [200, 204]
+        end
+      else
+        method = 'get'
+        expected_status ||= 200
+      end
+    end
+
+    method = method.to_s
+    function_args << 'body' if (method == 'post' || method == 'put') && options[:no_body].nil?
+    function_args << 'options={}, &block'
+
+    method_src = <<-METHOD
+    def #{name}(#{function_args.join(',')})
+      path = "#{path}"
+    METHOD
+
+    args.each_with_index do |arg, idx|
+      method_src << "path.sub! '#{arg}', #{function_args[idx]}.to_s\n"
+    end
+
+    if options[:no_body].nil?
+      if method == 'post' || method == 'put'
+        if options[:resource]
+          method_src << "options[:body] = {'#{options[:resource].to_s}' => body}\n"
+        else
+          method_src << "options[:body] = body\n"
+        end
+      end
+    end
+
+    method_src << "request :#{method}, path, options\n"
+
+    if expected_status
+      if expected_status.is_a?(Array)
+        method_src << 'raise InvalidResponse.new "Invalid response code #{response.code}" if ! [' + expected_status.join(',') + "].include?(response.code)\n"
+      else
+        method_src << 'raise InvalidResponse.new "Invalid response code #{response.code}" if response.code != ' + expected_status.to_s + "\n"
+      end
+    end
+
+    return_method = 'nil'
+    if options[:return].nil?
+      return_method = 'nil'
+    elsif options[:return].is_a?(Class)
+      return_method = options[:return].to_s
+    else
+      return_method = ":#{options[:return]}"
+    end
+
+    resource = options[:resource] ? "'#{options[:resource]}'" : 'nil'
+
+    method_src << "parse_response!\n"
+
+    method_src << "_handle_response response, :resource => #{resource}, :return => #{return_method}, &block\n"
+
+    method_src << "end\n"
+
+    if options[:instance]
+      options[:instance].instance_eval method_src, __FILE__, __LINE__
+    elsif options[:class]
+      options[:class].class_eval method_src, __FILE__, __LINE__
+    else
+      self.class_eval method_src, __FILE__, __LINE__
+    end
+  end
+
+  # Adds a route to the current object
+  def route(name, path, options={})
+    self.class.route name, path, options.merge(:instance => self)
+  end
+
+  # Creates routes for a RESTful API
+  #
+  # *resource_name* is the name of the items returned by the API,
+  # *collection_name* is the plural name of the items,
+  # *base_path* is the path to the collection
+  #
+  # Sets up 5 most common RESTful routes
+  #
+  # Example
+  #  /customers.json GET list of customers, POST to create a customer
+  #  /customers/1.json GET a customers, PUT to edit a customer, DELETE to delete a customer
+  #  JSON response returns {'customer': {'id':1, 'name':'Joe', ...}}
+  #
+  # Setup the RESTful routes
+  #  rest :customer, :customers, '/customers.json'
+  #  # same as
+  #  route :customers, '/customers.json', :resource => :customer
+  #  route :create_customer, '/customers.json', :resource => :customer
+  #  route :customer, '/customers/:customer_id.json', :resource => :customer
+  #  route :edit_customer, '/customers/:customer_id.json', :resource => :customer
+  #  route :delete_customer, '/customers/:customer_id.json', :resource => :customer
+  #
+  # Following methods are created
+  #  customers # return an array of customers
+  #  create_customer :name => 'Smith' # returns {'id' => 2, 'name' => 'Smith'}
+  #  customer 1 # return data for customer 1
+  #  edit_customer 1, :name => 'Joesph'
+  #  delete_customer 1
+  def self.rest(resource_name, collection_name, base_path, options={})
+    options[:resource] ||= resource_name
+    self.route collection_name, base_path, options
+    self.route resource_name, base_path.sub(/(\.[a-zA-Z0-9]+)$/, "/:#{resource_name}_id\\1"), options
+    self.route "edit_#{resource_name}", base_path.sub(/(\.[a-zA-Z0-9]+)$/, "/:#{resource_name}_id\\1"), options
+    self.route "create_#{resource_name}", base_path, options
+    self.route "delete_#{resource_name}", base_path.sub(/(\.[a-zA-Z0-9]+)$/, "/:#{resource_name}_id\\1"), options
+  end
+
+  # Creates the url
+  def build_url(path)
+    "#{self.base_uri}#{path}"
+  end
+
+  # Adds the basic_auth and cookie options
+  # This method should be overwritten as needed.
+  def build_options!(options)
+    options[:basic_auth] = self.basic_auth if self.basic_auth
+    if @cookies
+      options[:headers] ||= {}
+      options[:headers]['cookie'] = @cookies.to_a.collect{|c| "#{c[0]}=#{c[1]}"}.join('; ') + ';'
+    end
+  end
+
+  # Makes the request using HTTParty. Saves the method, path and options used.
+  def request(method, path, options)
+    build_options! options
+    url = build_url path
+    @request_method = method
+    @request_url = url
+    @request_options = options
+
+    @response = self.class.send(method, url, options)
+  end
+
+  # Will either call edit_<name> or add_<name> based on wether or not the body[:id] exists.
+  def save(name, body, options={})
+    id = body[:id] || body['id']
+    if id
+      if self.class.method_defined?("edit_#{name}")
+        self.send("edit_#{name}", id, body, options)
+      elsif self.class.method_defined?("update_#{name}")
+        self.send("update_#{name}", id, body, options)
+      else
+        raise MethodMissing.new "No edit/update method found for #{name}"
+      end
+    else
+      if self.class.method_defined?("add_#{name}")
+        self.send("add_#{name}", body, options)
+      elsif self.class.method_defined?("create_#{name}")
+        self.send("create_#{name}", body, options)
+      else
+        raise MethodMissing.new "No add/create method found for #{name}"
+      end
+    end
+  end
+
+  def method_missing(method, *args) #:nodoc:
+    if method.to_s =~ /^find_(.*?)_by_(.*)$/
+      find_method = "find_#{$1}"
+      find_args = $2.split '_and_'
+      raise MethodMissing.new "Missing method #{find_method}" unless self.class.method_defined?(find_method)
+      start = (self.method(find_method).arity + 1).abs
+      options = args[-1].is_a?(Hash) ? args[-1] : {}
+      options[:query] ||= {}
+      find_args.each_with_index do |find_arg, idx|
+        options[:query][find_arg] = args[start+idx]
+      end
+
+      if start > 0
+        send_args = args[0..(start-1)]
+        send_args << options
+        return self.send(find_method, *send_args)
+      else
+        return self.send(find_method, options)
+      end
+    else
+      super
+    end
+  end
+
+  # Convenience method for saving all cookies by default called from parse_response!.
+  def save_cookies!
+    return unless @response.headers.to_hash['set-cookie']
+    save_cookies @response.headers.to_hash['set-cookie']
+  end
+
+  # Parse an array of Set-cookie headers
+  def save_cookies(data)
+    @cookies ||= {}
+    data.collect { |cookie| cookie.split("\; ")[0].split('=') }.each do |c|
+      @cookies[c[0]] = c[1]
+    end
+  end
+
+  # Called after every valid request. Useful for parsing response headers.
+  # This method should be overwritten as needed.
+  def parse_response!
+    save_cookies!
+  end
+
+  protected
+
+  def _handle_response(response, opts={}, &block) #:nodoc:
+    if response.is_a?(Array)
+      response.to_a.collect do |obj|
+        _handle_response_object obj, opts, &block
+      end
+    else
+      _handle_response_object response, opts, &block
+    end
+  end
+
+  def _handle_response_object(obj, opts={}) #:nodoc:
+    obj = obj[opts[:resource]] unless opts[:resource].blank?
+    if opts[:return]
+      if opts[:return].is_a?(Class)
+        obj = opts[:return].new obj
+      else
+        obj = send opts[:return], obj
+      end
+    end
+    obj = yield(obj) if block_given?
+    obj
+  end
+end

data/spec/helper.rb

@@ -0,0 +1,19 @@
+require 'rubygems'
+require 'bundler'
+
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+
+require 'spec/autorun'
+require 'fakeweb'
+require 'json'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'resthome'
+

data/spec/lib/resthome_spec.rb

@@ -0,0 +1,317 @@
+require 'helper'
+
+describe RESTHome do
+
+  before(:each) do
+    @service_class = Class.new RESTHome
+    FakeWeb.allow_net_connect = false
+  end
+
+  class DummyProduct
+    attr_accessor :data
+    def initialize(resource)
+      raise 'Missing id' unless resource['id']
+      @data = resource
+    end
+  end
+
+  def fakeweb_response(method, url, code, value)
+    FakeWeb.clean_registry
+    status = [code.to_s, 'Ok']
+    FakeWeb.register_uri(method, url, :status => status, :body => value.to_json, :content_type => 'application/jsonrequest')
+  end
+
+  it "should build the url and options" do
+    @service = @service_class.new
+    @service.base_uri = 'http://test.dev'
+    @service.basic_auth = {:username => 'user', :password => 'x'}
+
+    @service.build_url('/items.json').should == 'http://test.dev/items.json'
+    options = {}
+    @service.build_options!(options)
+    options.should == {:basic_auth => {:username => 'user', :password => 'x'}}
+
+    options = {}
+    fakeweb_response(:get, 'http://user:x@test.dev/items.json', 200, {})
+    @service.request :get, '/items.json', options
+    @service.request_method.should == :get
+    @service.request_url.should == 'http://test.dev/items.json'
+    @service.request_options.should == {:basic_auth => {:username => 'user', :password => 'x'}}
+  end
+
+  it "should be able to create a route using GET" do
+    @service_class.route :products, '/products.json'
+    @service_class.method_defined?(:products).should be_true
+
+    @service = @service_class.new
+    @service.base_uri = 'http://test.dev'
+
+    fakeweb_response(:get, 'http://test.dev/products.json', 200,
+                     [{'product' => {'id' => 1, 'name' => 'Item1'}}, {'product' => {'id' => 2, 'name' => 'Item2'}}])
+    @service.products
+    @service.request_method.should == :get
+    @service.request_url.should == 'http://test.dev/products.json'
+    @service.request_options.should == {}    
+  end
+
+  it "should be able to create a route using POST" do
+    @service_class.route :create_product, '/products.json', :resource => 'product'
+    @service_class.route :add_products, '/products.json'
+    @service_class.method_defined?(:create_product).should be_true
+    @service_class.method_defined?(:add_products).should be_true
+
+    @service = @service_class.new
+    @service.base_uri = 'http://test.dev'
+
+    # Create
+    fakeweb_response(:post, 'http://test.dev/products.json', 201, {'product' => {'id' => 1, 'name' => 'Item1'}})
+    @service.create_product :name => 'Item1'
+    @service.request_method.should == :post
+    @service.request_url.should == 'http://test.dev/products.json'
+    @service.request_options.should == {:body => {'product' => {:name => 'Item1'}}}
+
+    # Add
+    fakeweb_response(:post, 'http://test.dev/products.json', 201, {'product' => {'id' => 2, 'name' => 'Item2'}})
+    @service.add_products 'product' => {:name => 'Item2'}
+    @service.request_method.should == :post
+    @service.request_url.should == 'http://test.dev/products.json'
+    @service.request_options.should == {:body => {'product' => {:name => 'Item2'}}}
+  end
+
+  it "should be able to create a route using PUT" do
+    @service_class.route :edit_product, '/products/:product_id.json', :resource => 'product'
+    @service_class.route :update_products, '/products/:product_id.json'
+    @service_class.method_defined?(:edit_product).should be_true
+    @service_class.method_defined?(:update_products).should be_true
+
+    @service = @service_class.new
+    @service.base_uri = 'http://test.dev'
+
+    # Edit
+    fakeweb_response(:put, 'http://test.dev/products/1.json', 200, {'product' => {'id' => 1, 'name' => 'Item1'}})
+    @service.edit_product 1, :name => 'Item1'
+    @service.request_method.should == :put
+    @service.request_url.should == 'http://test.dev/products/1.json'
+    @service.request_options.should == {:body => {'product' => {:name => 'Item1'}}}
+
+    # Update
+    fakeweb_response(:put, 'http://test.dev/products/2.json', 200, {'product' => {'id' => 2, 'name' => 'Item2'}})
+    @service.update_products 2, 'product' => {:name => 'Item2'}
+    @service.request_method.should == :put
+    @service.request_url.should == 'http://test.dev/products/2.json'
+    @service.request_options.should == {:body => {'product' => {:name => 'Item2'}}}
+  end
+
+  it "should be able to create a route using DELETE" do
+    @service_class.route :delete_product, '/products/:product_id.json'
+    @service_class.method_defined?(:delete_product).should be_true
+
+    @service = @service_class.new
+    @service.base_uri = 'http://test.dev'
+
+    # Delete
+    fakeweb_response(:delete, 'http://test.dev/products/1.json', 200, {})
+    @service.delete_product 1
+    @service.request_method.should == :delete
+    @service.request_url.should == 'http://test.dev/products/1.json'
+    @service.request_options.should == {}
+  end
+
+  it "should be able to setup RESTful routes" do
+    @service_class.rest :product, :products, '/products.json'
+    @service_class.method_defined?(:products).should be_true
+    @service_class.method_defined?(:product).should be_true
+    @service_class.method_defined?(:create_product).should be_true
+    @service_class.method_defined?(:edit_product).should be_true
+    @service_class.method_defined?(:delete_product).should be_true
+
+    @service = @service_class.new
+    @service.base_uri = 'http://test.dev'
+
+    # Get products
+    fakeweb_response(:get, 'http://test.dev/products.json', 200,
+                                [{'product' => {'id' => 1, 'name' => 'Item1'}},{'product' => {'id' => 2, 'name' => 'Item2'}}])
+    @service.products
+    @service.request_method.should == :get
+    @service.request_url.should == 'http://test.dev/products.json'
+    @service.request_options.should == {}    
+
+    # Get a product
+    fakeweb_response(:get, 'http://test.dev/products/1.json', 200, {'product' => {'id' => 1, 'name' => 'Item1'}})
+    @service.product 1
+    @service.request_method.should == :get
+    @service.request_url.should == 'http://test.dev/products/1.json'
+    @service.request_options.should == {}    
+
+    # Create
+    fakeweb_response(:post, 'http://test.dev/products.json', 201, {'product' => {'id' => 1, 'name' => 'Item1'}})
+    @service.create_product :name => 'Item1'
+    @service.request_method.should == :post
+    @service.request_url.should == 'http://test.dev/products.json'
+    @service.request_options.should == {:body => {'product' => {:name => 'Item1'}}}
+
+    # Edit
+    fakeweb_response(:put, 'http://test.dev/products/1.json', 200, {'product' => {'id' => 1, 'name' => 'Item1'}})
+    @service.edit_product 1, :name => 'Item1'
+    @service.request_method.should == :put
+    @service.request_url.should == 'http://test.dev/products/1.json'
+    @service.request_options.should == {:body => {'product' => {:name => 'Item1'}}}
+
+    # Delete
+    fakeweb_response(:delete, 'http://test.dev/products/1.json', 200, {})
+    @service.delete_product 1
+    @service.request_method.should == :delete
+    @service.request_url.should == 'http://test.dev/products/1.json'
+    @service.request_options.should == {}
+  end
+
+  it "should be able to save resources" do
+    @service_class.rest :product, :products, '/products.json'
+    @service_class.method_defined?(:create_product).should be_true
+    @service_class.method_defined?(:edit_product).should be_true
+
+    @service = @service_class.new
+    @service.base_uri = 'http://test.dev'
+
+    # Create
+    fakeweb_response(:post, 'http://test.dev/products.json', 201, {'product' => {'id' => 1, 'name' => 'Item1'}})
+    @service.save :product, :name => 'Item1'
+    @service.request_method.should == :post
+    @service.request_url.should == 'http://test.dev/products.json'
+    @service.request_options.should == {:body => {'product' => {:name => 'Item1'}}}
+
+    # Edit
+    fakeweb_response(:put, 'http://test.dev/products/1.json', 200, {'product' => {'id' => 1, 'name' => 'Item1'}})
+    @service.save :product, :id => 1, :name => 'Item1'
+    @service.request_method.should == :put
+    @service.request_url.should == 'http://test.dev/products/1.json'
+    @service.request_options.should == {:body => {'product' => {:id => 1, :name => 'Item1'}}}
+  end
+
+  it "should be able to change the return value using a class" do
+    @service_class.rest :product, :products, '/products.json', :return => DummyProduct
+    @service_class.method_defined?(:products).should be_true
+    @service_class.method_defined?(:product).should be_true
+
+    @service = @service_class.new
+    @service.base_uri = 'http://test.dev'
+
+    # Get products
+    fakeweb_response(:get, 'http://test.dev/products.json', 200,
+                                [{'product' => {'id' => 1, 'name' => 'Item1'}}, {'product' => {'id' => 2, 'name' => 'Item2'}}])
+    products = @service.products
+    @service.request_method.should == :get
+    @service.request_url.should == 'http://test.dev/products.json'
+    @service.request_options.should == {}    
+    products.is_a?(Array).should be_true
+    products[1].data['id'].should == 2
+
+    # Get a product
+    fakeweb_response(:get, 'http://test.dev/products/1.json', 200, {'product' => {'id' => 1, 'name' => 'Item1'}})
+    product = @service.product 1
+    @service.request_method.should == :get
+    @service.request_url.should == 'http://test.dev/products/1.json'
+    @service.request_options.should == {}    
+    product.is_a?(DummyProduct).should be_true
+    product.data['id'].should == 1
+  end
+
+  it "should be able to change the return value using a function" do
+    @service_class.send(:define_method, :handle_product) { |resource| resource['name'] }
+    @service_class.rest :product, :products, '/products.json', :return => :handle_product
+    @service_class.method_defined?(:products).should be_true
+    @service_class.method_defined?(:product).should be_true
+
+    @service = @service_class.new
+    @service.base_uri = 'http://test.dev'
+
+    # Get products
+    fakeweb_response(:get, 'http://test.dev/products.json', 200, [{'product' => {'id' => 1, 'name' => 'Item1'}},
+                                   {'product' => {'id' => 2, 'name' => 'Item2'}}])
+    products = @service.products
+    @service.request_method.should == :get
+    @service.request_url.should == 'http://test.dev/products.json'
+    @service.request_options.should == {}    
+    products.is_a?(Array).should be_true
+    products.should == ['Item1', 'Item2']
+
+    # Get a product
+    fakeweb_response(:get, 'http://test.dev/products/1.json', 200, {'product' => {'id' => 1, 'name' => 'Item1'}})
+    product = @service.product 1
+    @service.request_method.should == :get
+    @service.request_url.should == 'http://test.dev/products/1.json'
+    @service.request_options.should == {}    
+    product.is_a?(String).should be_true
+    product.should == 'Item1'
+  end
+
+  it "should be able to use a find_<resource> method to adjust the query option" do
+    @service_class.route :find_product, '/products/lookup.json', :resource => 'product'
+    @service_class.route :find_component, '/products/:product_id/components/lookup.json', :resource => 'component'
+    @service_class.method_defined?(:find_product).should be_true
+    @service_class.method_defined?(:find_component).should be_true
+
+    @service = @service_class.new
+    @service.base_uri = 'http://test.dev'
+
+    # Get a product
+    fakeweb_response(:get, 'http://test.dev/products/lookup.json?name=Item1', 200, {'product' => {'id' => 1, 'name' => 'Item1'}})
+    @service.find_product_by_name 'Item1'
+    @service.request_method.should == :get
+    @service.request_url.should == 'http://test.dev/products/lookup.json'
+    @service.request_options.should == {:query => {'name' => 'Item1'}}
+
+    # Get a component
+    fakeweb_response(:get, 'http://test.dev/products/1/components/lookup.json?name=C2', 200, {'component' => {'id' => 100, 'name' => 'C2'}})
+    @service.find_component_by_name 1, 'C2'
+    @service.request_method.should == :get
+    @service.request_url.should == 'http://test.dev/products/1/components/lookup.json'
+    @service.request_options.should == {:query => {'name' => 'C2'}}
+  end
+
+  it "should raise invalid response" do
+    @service_class.rest :product, :products, '/products.json'
+    @service_class.method_defined?(:product).should be_true
+
+    @service = @service_class.new
+    @service.base_uri = 'http://test.dev'
+
+    # Get a product
+    fakeweb_response(:get, 'http://test.dev/products/1.json', 400, {})
+    lambda{ @service.product 1 }.should raise_error(RESTHome::InvalidResponse)
+    @service.request_method.should == :get
+    @service.request_url.should == 'http://test.dev/products/1.json'
+    @service.request_options.should == {}
+  end
+
+  it "should raise error if find function is not found" do
+    @service_class.route :find_product, '/products/lookup.json', :resource => 'product'
+    @service_class.method_defined?(:find_product).should be_true
+
+    @service = @service_class.new
+    @service.base_uri = 'http://test.dev'
+
+    lambda{ @service.find_component_by_name 'Item1' }.should raise_error(RESTHome::MethodMissing)
+    lambda{ @service.save :product, {:name => 'Item1'} }.should raise_error(RESTHome::MethodMissing)
+    lambda{ @service.save :product, {:id => 1, :name => 'Item1'} }.should raise_error(RESTHome::MethodMissing)
+  end
+
+  it "should be able to use blocks on the response" do
+    @service_class.route :products, '/products.json', :resource => 'product'
+    @service_class.method_defined?(:products).should be_true
+
+    @service = @service_class.new
+    @service.base_uri = 'http://test.dev'
+
+    fakeweb_response(:get, 'http://test.dev/products.json', 200,
+                     [{'product' => {'id' => 1, 'name' => 'Item1'}}, {'product' => {'id' => 2, 'name' => 'Item2'}}])
+    @names = @service.products do |product|
+      product['name']
+    end
+
+    @names.should == ['Item1', 'Item2']
+    @service.request_method.should == :get
+    @service.request_url.should == 'http://test.dev/products.json'
+    @service.request_options.should == {}    
+  end
+end

data/tasks/spec.rake

@@ -0,0 +1,9 @@
+begin
+  require 'spec/rake/spectask'
+  Spec::Rake::SpecTask.new(:spec) do |spec|
+    spec.libs << 'lib' << 'spec'
+    spec.spec_files = FileList['spec/**/*_spec.rb']
+  end
+rescue LoadError => e
+  puts "unable to run specs from rake. gem install rspec"
+end

metadata

@@ -0,0 +1,286 @@
+--- !ruby/object:Gem::Specification 
+name: resthome
+version: !ruby/object:Gem::Version 
+  hash: 7
+  prerelease: false
+  segments: 
+  - 0
+  - 6
+  - 0
+  version: 0.6.0
+platform: ruby
+authors: 
+- Doug Youch
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-11-29 00:00:00 -05:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  prerelease: false
+  name: httparty
+  version_requirements: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  requirement: *id001
+  type: :runtime
+- !ruby/object:Gem::Dependency 
+  prerelease: false
+  name: bundler
+  version_requirements: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 23
+        segments: 
+        - 1
+        - 0
+        - 0
+        version: 1.0.0
+  requirement: *id002
+  type: :development
+- !ruby/object:Gem::Dependency 
+  prerelease: false
+  name: jeweler
+  version_requirements: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 1
+        segments: 
+        - 1
+        - 5
+        - 1
+        version: 1.5.1
+  requirement: *id003
+  type: :development
+- !ruby/object:Gem::Dependency 
+  prerelease: false
+  name: rcov
+  version_requirements: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  requirement: *id004
+  type: :development
+- !ruby/object:Gem::Dependency 
+  prerelease: false
+  name: fakeweb
+  version_requirements: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  requirement: *id005
+  type: :development
+- !ruby/object:Gem::Dependency 
+  prerelease: false
+  name: json
+  version_requirements: &id006 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  requirement: *id006
+  type: :development
+- !ruby/object:Gem::Dependency 
+  prerelease: false
+  name: rspec
+  version_requirements: &id007 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  requirement: *id007
+  type: :development
+- !ruby/object:Gem::Dependency 
+  prerelease: false
+  name: httparty
+  version_requirements: &id008 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  requirement: *id008
+  type: :runtime
+- !ruby/object:Gem::Dependency 
+  prerelease: false
+  name: bundler
+  version_requirements: &id009 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 23
+        segments: 
+        - 1
+        - 0
+        - 0
+        version: 1.0.0
+  requirement: *id009
+  type: :development
+- !ruby/object:Gem::Dependency 
+  prerelease: false
+  name: jeweler
+  version_requirements: &id010 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 1
+        segments: 
+        - 1
+        - 5
+        - 1
+        version: 1.5.1
+  requirement: *id010
+  type: :development
+- !ruby/object:Gem::Dependency 
+  prerelease: false
+  name: rcov
+  version_requirements: &id011 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  requirement: *id011
+  type: :development
+- !ruby/object:Gem::Dependency 
+  prerelease: false
+  name: fakeweb
+  version_requirements: &id012 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  requirement: *id012
+  type: :development
+- !ruby/object:Gem::Dependency 
+  prerelease: false
+  name: json
+  version_requirements: &id013 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  requirement: *id013
+  type: :development
+- !ruby/object:Gem::Dependency 
+  prerelease: false
+  name: rspec
+  version_requirements: &id014 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  requirement: *id014
+  type: :development
+description: Simple wrapper class generator for consuming RESTful web services
+email: doug@cykod.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE.txt
+- README.rdoc
+files: 
+- .document
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.rdoc
+- Rakefile
+- VERSION
+- examples/chargify_web_service.rb
+- examples/wordpress_web_service.rb
+- lib/resthome.rb
+- spec/helper.rb
+- spec/lib/resthome_spec.rb
+- tasks/spec.rake
+has_rdoc: true
+homepage: http://github.com/cykod/resthome
+licenses: 
+- MIT
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: RESTful web services consumer
+test_files: 
+- examples/chargify_web_service.rb
+- examples/wordpress_web_service.rb
+- spec/helper.rb
+- spec/lib/resthome_spec.rb