rest_api 0.1.0

data/lib/rest_api/request_handler.rb

@@ -0,0 +1,77 @@
+require "rest_api/request_handler/client"
+
+module RestApi  
+  module RequestHandler
+    class << self 
+      private
+      def client
+        RestApi::RequestHandler::Client
+      end
+    end
+
+    def self.make_request request_type, request_url, request_params = nil
+      request_params ||= {}
+      begin      
+        case request_type
+          when :put
+            client.put request_url, request_params
+          when :post
+            client.post request_url, request_params
+          when :delete
+            client.delete request_url, request_params
+          when :get
+            client.get request_url, request_params
+          else
+            raise Exception.new("Invalid request method")
+        end
+      rescue RestApi::Exceptions::ParseResponseException => e
+        raise e
+      rescue Exception => e
+        raise RestApi::Exceptions::ApiConnectionException.new(e)
+      end
+    end
+
+    # API CALL
+    # make the request call if the method match with get,put,post or delete
+    # the oder of the resources will be reversed
+    # Example: method_missing :get_casas_from_usuarios will make a GET to <APIURL>/usuarios/casas
+    # ----> request_params must can be a hash with the following keys 
+    # 1) :resources_params - contains params for the corresponding resource. 
+    #     The key of the param must has the name of the correspounding resource
+    # 2) :request_params - params of the header)
+    # ----> request_params must can be an Array of resources params
+    # Example: method_missing :get_casas_from_usuarios, 4 will make a GET to <APIURL>/usuarios/4/casas
+    # If the last item is a hash then it will be considered the :request_params
+
+    def self.method_missing(method_id, *arguments)
+      if request_type = API::RequestParser.get_request_type_from_method(method_id)
+        params = get_params_from_array_arguments arguments
+        request_url = API::RequestParser.get_url_from_method(method_id, params[:resources_params])
+        make_request request_type, request_url, params[:request_params]
+      else
+        super
+      end
+    end
+
+    def self.get_params_from_array_arguments arguments 
+      params_hash = { }
+      if arguments[0].is_a? Hash
+        if (arguments[0].has_key?(:resources_params) || arguments[0].has_key?(:request_params))
+          params_hash[:resources_params] = arguments[0][:resources_params]
+          params_hash[:request_params] = arguments[0][:request_params] 
+        else 
+          #the only argument is the request params
+          params_hash[:request_params] = arguments[0]
+        end
+      else
+        if arguments.last
+          params_hash[:request_params] = arguments.pop if arguments.last.is_a? Hash
+        end
+        params_hash[:resources_params] = Array.new arguments
+      end
+      params_hash.delete :request_params if params_hash[:request_params].nil?
+      params_hash
+    end
+
+  end
+end

data/lib/rest_api/version.rb

@@ -0,0 +1,3 @@
+module RestApi
+  VERSION = "0.1.0"
+end

data/lib/rest_api.rb

@@ -0,0 +1,46 @@
+require "rest_api/exceptions"
+require "rest_api/version"
+require "rest_api/api"
+require "rest_api/request_handler"
+require "rest_api/custom_api_method_call"
+
+module RestApi
+
+  @@custom_methods = []
+
+  # SETUP
+  def self.setup
+    yield self
+  end
+
+  def self.api_url
+    self.api.url
+  end
+
+  def self.api_url=(value)
+    if value.match(/.+\/$/)
+      self.api.url = value
+    else
+      self.api.url = value + "/"
+    end
+  end
+  
+  # api reference
+  def self.api
+    RestApi::API
+  end
+
+  # request reference
+  def self.request
+    RestApi::RequestHandler
+  end
+
+  # request parser reference
+  def self.request_parser
+    RestApi::API::RequestParser
+  end
+
+
+
+
+end

data/rest_api.gemspec

@@ -0,0 +1,23 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/rest_api/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Codus Tecnologia"]
+  gem.email         = ["vinicius.oyama@codus.com.br"]
+  gem.platform    = Gem::Platform::RUBY
+  gem.description   = %q{An API client for any application!}
+  gem.summary       = %q{An API client for any application!}
+  gem.homepage      = "https://github.com/codus/rest_api"
+
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = "rest_api"
+  gem.require_paths = ["lib"]
+  gem.version       = RestApi::VERSION
+
+
+  gem.add_dependency('activesupport', '~> 3.2')
+  gem.add_dependency('json', '~> 1.7')
+  gem.add_dependency('rest-client', '~> 1.6')
+end

data/spec/rest_api/api/request_parser_spec.rb

@@ -0,0 +1,199 @@
+# coding: utf-8
+
+require 'spec_helper'
+require 'ostruct'
+require 'set'
+
+describe "RestApi::API - url_parser" do
+  let (:fake_api_url) { "http://www.fakeurl.com/" }
+  before(:each) {
+    RestApi.setup do |config|
+      config.api_url = "http://www.fakeurl.com/"
+    end
+  }
+
+  describe "ensured_resources_names" do 
+    it "should return a new set if empty" do 
+      RestApi.api::RequestParser.send(:ensured_resources_names).should be_empty
+    end
+
+    it "should preserve the content" do 
+      RestApi.api::RequestParser.send(:ensured_resources_names) << :one
+      RestApi.api::RequestParser.send(:ensured_resources_names) << :two
+
+      RestApi.api::RequestParser.send(:ensured_resources_names).length.should be == 2
+    end
+  end
+
+  describe "ensure_resource_name" do 
+    it "should add the resource name to the set of ensured resources names" do 
+      RestApi.api::RequestParser.ensure_resource_name :my_resource
+      RestApi.api::RequestParser.send(:ensured_resources_names).include?("my_resource").should be == true
+    end
+
+    it "should accept many arguments" do 
+      RestApi.api::RequestParser.ensure_resource_name :my_resource1, :my_resource2, :my_resource13
+      RestApi.api::RequestParser.send(:ensured_resources_names).include?("my_resource1").should be == true
+      RestApi.api::RequestParser.send(:ensured_resources_names).include?("my_resource2").should be == true
+      RestApi.api::RequestParser.send(:ensured_resources_names).include?("my_resource13").should be == true
+    end
+
+    it "should  raise ArgumentError when there is no argument" do 
+      lambda {
+        RestApi.api::RequestParser.ensure_resource_name
+      }.should raise_exception(ArgumentError)
+    end
+  end
+
+
+  describe "reset_ensure_resource_name" do 
+    it "should clear the ensured_resources_names set" do 
+      RestApi.api::RequestParser.ensure_resource_name :my_resource
+      RestApi.api::RequestParser.ensure_resource_name :my_resource2
+      RestApi.api::RequestParser.reset_ensure_resource_name
+      
+      RestApi.api::RequestParser.send(:ensured_resources_names).length.should be == 0
+    end
+  end
+
+  describe "get_url_from_method" do 
+    it "should return the corret url with params" do 
+      RestApi.api::RequestParser.send(:get_url_from_method, :get_casas_from_usuarios, {:usuarios => 3}).should be == "#{fake_api_url}usuarios/3/casas"
+
+      RestApi.api::RequestParser.send(:get_url_from_method, :put_casas_from_usuarios, {:usuarios => 3, :casas => 5}).should be == "#{fake_api_url}usuarios/3/casas/5"
+
+      RestApi.api::RequestParser.send(:get_url_from_method, :get_show_usuarios, {:usuarios => 3}).should be == "#{fake_api_url}usuarios/3/show"
+      RestApi.api::RequestParser.send(:get_url_from_method, :delete_usuarios, {:usuarios => 2}).should be == "#{fake_api_url}usuarios/2"
+    end
+
+    it "should return the corret url  without params" do 
+      RestApi.api::RequestParser.send(:get_url_from_method, :get_casas_from_usuarios).should be == "#{fake_api_url}usuarios/casas"
+    end
+  end
+
+  describe "get_url_from_map" do 
+    let(:array_resources_name) { ["casas", "carros", "usuarios"] }
+    let(:resources_map) { 
+      map = OpenStruct.new
+      map.casas = "casas"
+      map.carros = "onibus"
+      map.usuarios = "administrador"
+      map
+    }
+
+    it "should return the corret url - with params (hash 1 item)" do 
+      RestApi.api::RequestParser.send(:get_url_from_map, array_resources_name, resources_map, {:casas => 4}).should be == "#{fake_api_url}casas/4/onibus/administrador"
+    end
+
+    it "should return the corret url - with params (hash 3 itens)" do 
+      RestApi.api::RequestParser.send(:get_url_from_map, array_resources_name, resources_map, {:casas => 4, :carros => 5, :usuarios => 7}).should be == "#{fake_api_url}casas/4/onibus/5/administrador/7"
+    end
+
+    it "should return the corret url - with params (array 1 item)" do 
+      RestApi.api::RequestParser.send(:get_url_from_map, array_resources_name, resources_map, [4]).should be == "#{fake_api_url}casas/4/onibus/administrador"
+    end
+
+    it "should return the corret url - with params (array 3 itens)" do 
+      RestApi.api::RequestParser.send(:get_url_from_map, array_resources_name, resources_map, [4, 5, 7]).should be == "#{fake_api_url}casas/4/onibus/5/administrador/7"
+    end
+
+    it "should return the corret url -without params" do 
+      RestApi.api::RequestParser.send(:get_url_from_map, array_resources_name, resources_map).should be == "#{fake_api_url}casas/onibus/administrador"
+    end
+
+    it "should return the corret url 2 - without params " do 
+      map = OpenStruct.new
+      map.test = "test"
+      RestApi.api::RequestParser.send(:get_url_from_map, ["test"], map).should be == "#{fake_api_url}test"
+    end
+  end
+
+  describe "get_request_type_from_method" do 
+    [:put, :post, :delete, :get].each do |tipo_do_request_esperado| 
+      it "should return :#{tipo_do_request_esperado} when the method name start with #{tipo_do_request_esperado}" do 
+        RestApi.api::RequestParser.send(:get_request_type_from_method, "#{tipo_do_request_esperado.to_s}_resource".to_sym).should be == tipo_do_request_esperado
+        RestApi.api::RequestParser.send(:get_request_type_from_method, "#{tipo_do_request_esperado.to_s}_resource".to_sym).should be == tipo_do_request_esperado
+        RestApi.api::RequestParser.send(:get_request_type_from_method, "#{tipo_do_request_esperado.to_s}_resource".to_sym).should be == tipo_do_request_esperado
+        RestApi.api::RequestParser.send(:get_request_type_from_method, "#{tipo_do_request_esperado.to_s}_resource".to_sym).should be == tipo_do_request_esperado
+      end
+    end
+  end
+
+  describe "get_url_tokens_from_method" do 
+    ["resource1", "resource2", "resource3"].each do |resource|
+      it "one resource - resource name: #{resource}" do
+        RestApi.api::RequestParser.send(:get_url_tokens_from_method, "get_#{resource}".to_sym).should be == [resource]
+        RestApi.api::RequestParser.send(:get_url_tokens_from_method, "put_#{resource}".to_sym).should be == [resource]
+        RestApi.api::RequestParser.send(:get_url_tokens_from_method, "delete_#{resource}".to_sym).should be == [resource]
+        RestApi.api::RequestParser.send(:get_url_tokens_from_method, "post_#{resource}".to_sym).should be == [resource]
+      end
+
+      ["subresource1", "subresource2", "subresource3"].each do |sub_resource|
+        it "two sub resources" do
+          RestApi.api::RequestParser.send(:get_url_tokens_from_method, "get_#{resource}_from_#{sub_resource}".to_sym).should be == [sub_resource, resource]
+          RestApi.api::RequestParser.send(:get_url_tokens_from_method, "put_#{resource}_from_#{sub_resource}".to_sym).should be == [sub_resource, resource]
+          RestApi.api::RequestParser.send(:get_url_tokens_from_method, "delete_#{resource}_from_#{sub_resource}".to_sym).should be == [sub_resource, resource]
+          RestApi.api::RequestParser.send(:get_url_tokens_from_method, "post_#{resource}_from_#{sub_resource}".to_sym).should be == [sub_resource, resource]
+        end
+      end
+    end
+
+    it "should kept the ensured resources names - one resource" do 
+      RestApi.api::RequestParser.stub(:ensured_resources_names).and_return(Set.new(["public_users", "some_resource"]))
+      RestApi.api::RequestParser.get_url_tokens_from_method("get_public_users".to_sym).should be == ["public_users"]
+    end
+
+    it "should kept the ensured resources names - two resources" do 
+      RestApi.api::RequestParser.stub(:ensured_resources_names).and_return(Set.new(["public_users", "some_resources"]))
+      RestApi.api::RequestParser.get_url_tokens_from_method("get_public_users_from_some_resources_in_admins_from_system".to_sym).sort.should be == ["public_users", "some_resources", "admins", "system"].sort
+    end
+  end
+
+  describe "insert_resources_params_in_tokens_array" do 
+    it "should insert the resource param as string after resource name - one subresource" do 
+      tokens_array = ["usuarios", "eventos"]
+      RestApi.api::RequestParser.send(:insert_resources_params_in_tokens_array, tokens_array, {:usuarios => 3}).should be == ["usuarios", "3", "eventos"]
+    end
+
+    it "should insert the resource param as string after resource name - four subresources" do 
+      tokens_array = ["usuarios", "eventos", "carros", "festas"]
+      RestApi.api::RequestParser.send(:insert_resources_params_in_tokens_array, tokens_array, {:usuarios => 5, :carros => 234}).should be == ["usuarios", "5", "eventos", "carros", "234", "festas"]
+    end
+
+    it "should ignore if no params" do 
+      tokens_array = ["usuarios", "eventos", "carros", "festas"]
+      RestApi.api::RequestParser.send(:insert_resources_params_in_tokens_array, tokens_array, {}).should be == ["usuarios", "eventos", "carros", "festas"]
+    end
+
+    it "should accept params as an array - same number of resources" do 
+      tokens_array = ["usuarios", "eventos", "carros", "festas"]
+      RestApi.api::RequestParser.send(:insert_resources_params_in_tokens_array, tokens_array, [1,2,3,4]).should be == ["usuarios", "1", "eventos", "2", "carros", "3", "festas", "4"]
+    end
+
+    it "should accept params as an array - differnet number of resources" do 
+      tokens_array = ["usuarios", "eventos", "carros", "festas"]
+      RestApi.api::RequestParser.send(:insert_resources_params_in_tokens_array, tokens_array, [1,2,4]).should be == ["usuarios", "1", "eventos", "2", "carros", "4", "festas"]
+    end
+  end
+
+  describe "pluralize_resource" do 
+    it "should not insert s after digit" do 
+      RestApi.api::RequestParser.send(:pluralize_resource, "3").should be == "3"
+      RestApi.api::RequestParser.send(:pluralize_resource, "4533").should be == "4533"
+      RestApi.api::RequestParser.send(:pluralize_resource, "resource3").should be == "resource3"
+    end
+
+    it "should not insert s after s" do 
+      RestApi.api::RequestParser.send(:pluralize_resource, "kiss").should be == "kiss"
+      RestApi.api::RequestParser.send(:pluralize_resource, "asas").should be == "asas"
+      RestApi.api::RequestParser.send(:pluralize_resource, "foos").should be == "foos"
+    end
+
+
+    it "should not insert after anything except digit or s" do 
+      RestApi.api::RequestParser.send(:pluralize_resource, "usuario").should be == "usuarios"
+      RestApi.api::RequestParser.send(:pluralize_resource, "peixe").should be == "peixes"
+      RestApi.api::RequestParser.send(:pluralize_resource, "carro").should be == "carros"
+    end
+  end
+end

data/spec/rest_api/api_spec.rb

@@ -0,0 +1,13 @@
+# coding: utf-8
+
+require 'spec_helper'
+
+describe "RestApi.api" do
+  let (:fake_api_url) { "http://www.fakeurl.com/" }
+  before(:each) {
+    RestApi.unmap_resources
+    RestApi.setup do |config|
+      config.api_url = "http://www.fakeurl.com/"
+    end
+  }
+end

data/spec/rest_api/custom_api_method_spec.rb

@@ -0,0 +1,90 @@
+# coding: utf-8
+
+require 'spec_helper'
+require 'fakeweb'
+
+describe "RestApi" do
+  let (:fake_api_url) { "http://www.fakeurl.com/" }
+  before(:each) {
+    RestApi.unmap_resources
+    RestApi.setup do |config|
+      config.api_url = "http://www.fakeurl.com/"
+    end
+    FakeWeb.allow_net_connect = false 
+  }
+
+  describe "unmap_resources" do
+    it "should remove all methods" do 
+      RestApi.map_custom_api_method :put, :casa_in_usuarios
+      RestApi.unmap_resources
+      RestApi.request.respond_to?(:put_casa_in_usuarios).should be == false
+    end
+  end
+
+  describe "add_custom_api_method" do
+    it "should add a method to the api module" do 
+      RestApi.map_custom_api_method :put, :casa_in_usuarios
+      RestApi.request.respond_to?(:put_casa_in_usuarios).should be == true
+      RestApi.mapped_methods.include?(:put_casa_in_usuarios).should be == true
+    end
+  
+    context "Method add - widthout arg" do
+      it "should return the url of the added method - mapped resources" do 
+        RestApi.map_custom_api_method :put, :casas_in_usuarios do |map| 
+          map.casas = "casinha"
+          map.usuarios = "usuarionsinhos"
+        end
+        RestApi::RequestHandler.should_receive(:make_request).with(:put, "#{fake_api_url}usuarionsinhos/casinha", {:usuarios_id => 4}).and_return({ "status" => "ok" })
+        RestApi.request.put_casas_in_usuarios(:usuarios_id => 4).should be == { "status" => "ok" }
+      end
+
+      it "should return the url of the added method - no mapped resources" do 
+        RestApi.map_custom_api_method :put, :casas_in_usuarios do |map| 
+          map.casas = "casinha"
+          map.usuarios = "usuarionsinhos"
+        end
+        RestApi::RequestHandler.should_receive(:make_request).with(:put, "#{fake_api_url}usuarionsinhos/4/casinha", {:casinh_id => 8}).and_return({ "status" => "ok" })
+        RestApi.request.put_casas_in_usuarios(4, :casinh_id => 8).should be == { "status" => "ok" }
+      end
+    end
+  end
+
+  describe "add_restful_api_methods" do
+    before(:each) {
+      RestApi.setup do |config|
+        config.api_url = "http://www.fakeurl.com/"
+        config.add_restful_api_methods :users
+      end
+    }
+
+    it "should add a get method to the api request module" do 
+      RestApi.request.respond_to?(:get_users).should be == true
+      RestApi.mapped_methods.include?(:get_users).should be == true
+    end
+
+    it "should add a put method to the api request module" do 
+      RestApi.request.respond_to?(:put_users).should be == true
+      RestApi.mapped_methods.include?(:put_users).should be == true
+    end
+
+
+    it "should add a post method to the api request module" do 
+      RestApi.request.respond_to?(:post_users).should be == true
+      RestApi.mapped_methods.include?(:post_users).should be == true
+    end
+
+
+    it "should add a delete method to the api request module" do 
+      RestApi.request.respond_to?(:delete_users).should be == true
+      RestApi.mapped_methods.include?(:delete_users).should be == true
+    end
+
+    it "should accept a block to map the resources" do 
+      RestApi.add_restful_api_methods :person_in_places do |map|
+        map.person = "people"
+      end
+      RestApi::RequestHandler.should_receive(:make_request).with(:get, "http://www.fakeurl.com/places/2/people", nil).and_return("")
+      RestApi.request.get_person_in_places(2)
+    end
+  end
+end

data/spec/rest_api/request_handler/client_spec.rb

@@ -0,0 +1,93 @@
+# coding: utf-8
+
+require 'spec_helper'
+require 'rest_client'
+require 'fakeweb'
+
+describe "RestApi::RequestHandler - client" do
+  before :all do
+    FakeWeb.allow_net_connect = false
+    FakeWeb.register_uri(:get, "http://www.teste.com.br", :body => "{ \"casa\":  \"teste\", \"rua\": \"teste2\"}")
+    FakeWeb.register_uri(:post, "http://www.teste.com.br/resource2", :body => "{ \"casa2\":  \"teste\", \"rua\": \"teste2\"}")
+    FakeWeb.register_uri(:put, "http://www.teste.com.br/resource3", :body => "{ \"casa3\":  \"teste\", \"rua3\": \"teste2\"}")
+    FakeWeb.register_uri(:delete, "http://www.teste.com.br/user/3", :body => "{ \"casa6\":  \"teste\", \"rua6\": \"teste2\"}")
+  end
+
+  context "rest_client" do 
+    it "should call the url with querystring" do 
+      FakeWeb.register_uri(:get, "http://www.teste.com.br/user/3?name=value", :body => "{ \"casa6\":  \"teste\", \"rua6\": \"teste2\"}")
+      RestClient.get "http://www.teste.com.br/user/3", :params => {:name => "value"}
+    end
+  end
+
+  it "should raise an ParseResponseException if the response is invalid when response is invalid" do 
+    RestClient.should_receive(:get).with("http://www.teste.com.br", :params => {}, :accept=>:json).and_return("")
+    lambda {
+      RestApi::RequestHandler::Client.send(:get, "http://www.teste.com.br")
+    }.should raise_exception(RestApi::Exceptions::ParseResponseException)
+  end
+  
+  describe "get" do 
+    it "should call RestClient get" do 
+      RestClient.should_receive(:get).with("http://www.teste.com.br", :params => {}, :accept=>:json).and_return("{ \"casa\":  \"teste\", \"rua\": \"teste2\"}")
+      RestApi::RequestHandler::Client.send(:get, "http://www.teste.com.br")
+    end
+
+    it "should call parse_response" do 
+      RestApi::RequestHandler::Client.should_receive(:parse_response)
+      RestApi::RequestHandler::Client.send(:get, "http://www.teste.com.br/")
+    end
+
+    it "should return a parsed json hash" do 
+      RestApi::RequestHandler::Client.send(:get, "http://www.teste.com.br/").should be == {"casa"=>"teste", "rua"=>"teste2"}
+    end
+  end
+
+  describe "post" do 
+    it "should call RestClient post" do 
+      RestClient.should_receive(:post).with("http://www.teste.com.br/resource2", { :param => true }, :accept=>:json).and_return("{ \"casa\":  \"teste\", \"rua\": \"teste2\"}")
+      RestApi::RequestHandler::Client.send(:post, "http://www.teste.com.br/resource2", { :param => true })
+    end
+
+    it "should call parse_response" do 
+      RestApi::RequestHandler::Client.should_receive(:parse_response)
+      RestApi::RequestHandler::Client.send(:post, "http://www.teste.com.br/resource2")
+    end
+
+    it "should return a parsed json hash" do 
+      RestApi::RequestHandler::Client.send(:post, "http://www.teste.com.br/resource2").should be == {"casa2"=>"teste", "rua"=>"teste2"}
+    end
+  end
+  
+  describe "put" do 
+    it "should call RestClient post" do 
+      RestClient.should_receive(:put).with("http://www.teste.com.br/resource3", { :param => 3 }, :accept=>:json).and_return("{ \"casa\":  \"teste\", \"rua\": \"teste2\"}")
+      RestApi::RequestHandler::Client.send(:put, "http://www.teste.com.br/resource3", { :param => 3 })
+    end
+
+    it "should call parse_response" do 
+      RestApi::RequestHandler::Client.should_receive(:parse_response)
+      RestApi::RequestHandler::Client.send(:put, "http://www.teste.com.br/resource3")
+    end
+
+    it "should return a parsed json hash" do 
+      RestApi::RequestHandler::Client.send(:put, "http://www.teste.com.br/resource3").should be == {"casa3"=>"teste", "rua3"=>"teste2"}
+    end
+  end
+
+  describe "delete" do 
+    it "should call RestClient post" do 
+      RestClient.should_receive(:delete).with("http://www.teste.com.br/user/3", :params => {}, :accept=>:json).and_return("{ \"casa\":  \"teste\", \"rua\": \"teste2\"}")
+      RestApi::RequestHandler::Client.send(:delete, "http://www.teste.com.br/user/3")
+    end
+
+    it "should call parse_response" do 
+      RestApi::RequestHandler::Client.should_receive(:parse_response)
+      RestApi::RequestHandler::Client.send(:delete, "http://www.teste.com.br/user/3")
+    end
+
+    it "should return a parsed json hash" do 
+      RestApi::RequestHandler::Client.send(:delete, "http://www.teste.com.br/user/3").should be == {"casa6"=>"teste", "rua6"=>"teste2"}
+    end
+  end
+end