rest_api 0.1.0 → 0.1.1

data/README.md

@@ -1,6 +1,6 @@
 # RestApi - RESTful client for everything
 
-**RestApi** aims to be a generic RESTful client for ruby. The goal is to build a friendly API client that you can use right away with minimum configuration. But, if you want, you can bend the client as you wish
+**RestApi** aims to be a generic RESTful client for ruby. The goal is to build a friendly API client that you can use right away with minimum configuration. But, if you want, you can bend the client as you wish.
 
 ## Installation
 
@@ -38,7 +38,7 @@ Just put the above code in /config/initializers/rest_api.rb
 
 ## Usage
 
-Every request must be made through the RestApi.request object. 
+Every request must be made through the RestApi.request object. And the expected response must be in JSON format. Then it will be parsed to a ruby hash.
 
 ```ruby
 RestApi.request.my_request_method(arguments)
@@ -59,26 +59,26 @@ These are reserved words that the resources cannot use as name:
 **EXAMPLES**
 
 ```ruby 
-RestApi.request.get_users  
 # GET to "http://www.myapiurl.com/users"
+RestApi.request.get_users  
 
-RestApi.request.get_cars_from_users    
 # GET to "http://www.myapiurl.com/users/cars"
+RestApi.request.get_cars_from_users    
 
-RestApi.request.get_cars_users  
 # GET to "http://www.myapiurl.com/users/cars"
+RestApi.request.get_cars_users  
 
-RestApi.request.post_cars   
 # POST to "http://www.myapiurl.com/cars"
+RestApi.request.post_cars   
 
-RestApi.request.put_cars_users  
 # PUT to "http://www.myapiurl.com/users/cars"
+RestApi.request.put_cars_users  
 
-RestApi.request.delete_users  
 # DELETE to "http://www.myapiurl.com/users"
+RestApi.request.delete_users  
 
-RestApi.request.delete_houses_from_users  
 # DELETE to "http://www.myapiurl.com/users/houses"
+RestApi.request.delete_houses_from_users  
 ```
 
 ### arguments
@@ -97,17 +97,17 @@ You can pass a hash in the :resource_params where, for each pair, the key is the
 **EXAMPLES**
 
 ```ruby 
-RestApi.request.delete_users(:resources_params => { :users => 7})  
 # DELETE to "http://www.myapiurl.com/users/7" 
+RestApi.request.delete_users(:resources_params => { :users => 7})  
 
-RestApi.request.put_cars_in_users(:resources_params => { :users => 7})  
 # PUT to "http://www.myapiurl.com/users/7/cars/" 
+RestApi.request.put_cars_in_users(:resources_params => { :users => 7})  
 
-RestApi.request.put_cars_in_users(:resources_params => { :cars => 18})  
-# PUT to "http://www.myapiurl.com/users/cars/18" 
+# PUT to "http://www.myapiurl.com/users/5/cars/18" 
+RestApi.request.put_cars_in_users(:resources_params => { :cars => 18, :users => 5})   
 
-RestApi.request.get_users(:resources_params => { :users => 18})  
 # GET to "http://www.myapiurl.com/users/18" 
+RestApi.request.get_users(:resources_params => { :users => 18})  
 ```
 
 **:request_params**
@@ -118,11 +118,11 @@ You can pass a hash in the :request_params where, for each pair, the key is the
 **EXAMPLE**
 
 ```ruby 
-RestApi.request.post_users(:request_params => { :user => {:name => "myname"})
 # POST to "http://www.myapiurl.com/users/" with "{ :user => {:name => "name"}" in the header
+RestApi.request.post_users(:request_params => { :user => {:name => "myname"}})
 
-RestApi.request.get_users(:request_params => { :user => {:name => "name"})  
 # GET to "http://www.myapiurl.com/users?name=myname" 
+RestApi.request.get_users(:request_params => { :user => {:name => "name"}})  
 ```
 
 **Using both :resource_params and :request_params**
@@ -133,11 +133,14 @@ Obviously you can use them together.
 **EXAMPLES**
 
 ```ruby 
-RestApi.request.get_cars_from_users(:request_params => { :page => 5, :resource_params => { :users => 8})
 # GET to "http://www.myapiurl.com/users/8/cars?page=5" 
+RestApi.request.get_cars_from_users(:request_params => { :page => 5}, 
+                                    :resources_params => { :users => 8})
 
-RestApi.request.post_cars_in_users(:request_params => { :car => {:model => "ferrari"}, :resource_params => { :users => 8})
-# POST to "http://www.myapiurl.com/users/8/cars" with "{ :car => {:model => "ferrari"}" in the header
+# POST to "http://www.myapiurl.com/users/8/cars" 
+# with "{ :car => {:model => "ferrari"}" in the header
+RestApi.request.post_cars_in_users(:request_params => { :car => {:model => "ferrari"}}, 
+                                   :resources_params => { :users => 8})
 ```
 
 **Short Syntax**
@@ -147,17 +150,17 @@ You can pass as many arguments you want. They will be considered as a **:resourc
 **EXAMPLES**
 
 ```ruby 
-RestApi.request.get_users(18)
 # GET to "http://www.myapiurl.com/users/18" 
+RestApi.request.get_users(18)
 
-RestApi.request.get_cars_from_users(18)
 # GET to "http://www.myapiurl.com/users/18/cars" 
+RestApi.request.get_cars_from_users(18)
 
-RestApi.request.get_cars_from_users(18, 6) 
 # GET to "http://www.myapiurl.com/users/18/cars/6" 
+RestApi.request.get_cars_from_users(18, 6) 
 
-RestApi.request.put_cars_in_users(18, 6) 
 # PUT to "http://www.myapiurl.com/users/18/cars/6" 
+RestApi.request.put_cars_in_users(18, 6) 
 ```
 
 **IF** the last argument is a hash then it will be considered the **:request_params**.
@@ -165,14 +168,16 @@ RestApi.request.put_cars_in_users(18, 6)
 **EXAMPLES**
 
 ```ruby 
-RestApi.request.get_cars_from_users(8, :page => 5)
 # GET to "http://www.myapiurl.com/users/8/cars?page=5"
+RestApi.request.get_cars_from_users(8, :page => 5)
 
+# PUT to "http://www.myapiurl.com/users/18/"  
+# with { :user => {:name => "myname"} } in the header
 RestApi.request.put_users(18, :user => {:name => "myname"})
-# PUT to "http://www.myapiurl.com/users/18/"  with { :user => {:name => "myname"} } in the header
 
+# PUT to "http://www.myapiurl.com/users/18/cars/6"  
+# with { :car => {:model => "mercedes"} } in the header
 RestApi.request.put_cars_in_users(18, 6, :car => {:model => "mercedes"})
-# PUT to "http://www.myapiurl.com/users/18/cars/6"  with { :car => {:model => "mercedes"} } in the header
 ```
 
 If there is only one argument and it is a hash then it will be considered as the **:request_params**.
@@ -180,16 +185,17 @@ If there is only one argument and it is a hash then it will be considered as the
 **EXAMPLES**
 
 ```ruby
+# GET to "http://www.myapiurl.com/users/?page=5
 RestApi.request.get_users(:page => 5)
-# GET to "http://www.myapiurl.com/users/?page=8
 
-RestApi.request.post_cars_in_users(:car => {:model => "mercedes"})
-# POST to "http://www.myapiurl.com/users/18/cars/6"  with {:car => {:model => "mercedes"} in the header
+# POST to "http://www.myapiurl.com/users/18/cars/6" 
+# with {:car => {:model => "mercedes"} in the header
+RestApi.request.post_cars_in_users(18, 6, :car => {:model => "mercedes"})
 ```
 
 ## Advanced Configuration
 
-There are some considerations in the current implementation that you must be aware of to make RestApi to work properly. Here we will show them to you and the configuration for every case.
+There are some considerations in the current implementation that you must be aware of to make RestApi work properly. Here we will show them to you and the configuration for each case.
 
 #### RestApi.request_parser#ensure_resource_name
 ****
@@ -204,7 +210,7 @@ RestApi.request.get_public_users
 
 It will make a GET to:
 
-*http://www.myapiurl.com/users/public_users*
+*http://www.myapiurl.com/users/users/public*
 
 To make things work properly you must ensure the name of the resource like this:
 
@@ -225,12 +231,12 @@ It will make a GET to:
 And you can do something like this:
 
 ```ruby
-RestApi.request.get_public_users :resources_params => {:public_users => 2}
+RestApi.request.get_public_users(:resources_params => {:public_users => 2})
 ``` 
 
 It will make a GET to: 
 
-*http://www.myapiurl.com/public_users/2
+*http://www.myapiurl.com/public_users/2*
 
 You can ensure more than one resource name at once:
 
@@ -260,7 +266,7 @@ And you have a RESTful url like this:
 
 *http://www.myapiurl.com/categories/2/categories*
 
-That allows to get/post/put/delete the child categories of category 2. But if you try to do: 
+That allows you to get/post/put/delete the child categories of category 2. But if you try to do: 
 
 ```ruby
 RestApi.request.get_categories_in_categories(2)
@@ -289,7 +295,7 @@ end
 Now when you do:
 
 ```ruby
-RestApi.request.get_subcategories_in_categories :resources_params => {:subcategories => 2}
+RestApi.request.get_subcategories_in_categories(:resources_params => {:categories => 2})
 ```
 
 Will make a GET to:
@@ -301,14 +307,14 @@ If you don't define a map to some resource name in the method, it will be parsed
 #### RestApi#add_restful_api_methods
 ****
 
-Note that *map_custom_api_method* only define one request type per time. If you try: 
+Note that *map_custom_api_method* only declares one method per call. If you try: 
 
 ```ruby
 RestApi.map_custom_api_method :get, :subcategories_in_categories do |map| 
   map.subcategories = "categories"
 end
 
-RestApi.request.put_subcategories_in_categories :resources_params => {:categories => 2}
+RestApi.request.put_subcategories_in_categories(:resources_params => {:categories => 2})
 ```
 
 The custom *GET* mapping will be ignored and will be made a *PUT* request with the default map to:
@@ -328,7 +334,7 @@ end
 Now you can do:
 
 ```ruby
-RestApi.request.put_subcategories_in_categories :resources_params => {:subcategories => 5, :categories => 2}
+RestApi.request.put_subcategories_in_categories(:resources_params => {:subcategories => 5, :categories => 2})
 ```
 That a PUT will be made to:
 
@@ -347,6 +353,7 @@ RestApi.unmap_resources
 
 Here we will put the features that will be implemented in the future.
 
+* Module architecture refactoring
 * API autentication  
 * Extend the client to accept others formats than JSON
 * Create the RestApi::Model to work like an ActiveRecord model (ok. we have a long way to go)

data/lib/rest_api/api/request_parser.rb

@@ -4,18 +4,18 @@ module RestApi
   module API
     module RequestParser
       class << self
-        def get_url_from_method method_id, resources_params = nil
-          tokens_array = get_url_tokens_from_method method_id
-          tokens_array = insert_resources_params_in_tokens_array tokens_array, resources_params unless (resources_params.nil? || resources_params.empty?)
+        def get_url_from_method(method_id, resources_params = nil)
+          tokens_array = get_url_tokens_from_method(method_id)
+          tokens_array = insert_resources_params_in_tokens_array(tokens_array, resources_params) unless (resources_params.nil? || resources_params.empty?)
           API.url + tokens_array.join("/")
         end
 
-        def get_url_from_map array_resources_names, resources_map, resources_params = nil
+        def get_url_from_map(array_resources_names, resources_map, resources_params = nil)
           # insert the params before translate the url with a map so the rousources_params
           # must be relative the array resrouces_names
           # tokens_array = array_resources_names
 
-          tokens_array = insert_resources_params_in_tokens_array array_resources_names, resources_params unless (resources_params.nil? || resources_params.empty?)
+          tokens_array = insert_resources_params_in_tokens_array(array_resources_names, resources_params) unless (resources_params.nil? || resources_params.empty?)
           tokens_array ||= array_resources_names
           tokens_array_mapped = tokens_array.map do |resource_name|
             if resources_map.respond_to?(resource_name.to_sym)
@@ -28,12 +28,12 @@ module RestApi
           API.url + tokens_array_mapped.join("/")
         end
 
-        def get_request_type_from_method method_id
+        def get_request_type_from_method(method_id)
           request_type = method_id.to_s.match(/^get|put|delete|post/i)
           request_type.nil? ? request_type : request_type[0].to_sym 
         end
 
-        def get_url_tokens_from_method method_id
+        def get_url_tokens_from_method(method_id)
           method_name_without_pronouns = method_id.to_s.gsub(/_(in|of|from)_/,"_").gsub(/(put|get|post|delete)_/, "")
           method_name_with_reserved_mask = method_name_without_pronouns
           ensured_resources_names.each { |ensured_resource_name| 
@@ -43,25 +43,30 @@ module RestApi
           url_tokens.reverse
         end
 
-        def insert_resources_params_in_tokens_array tokens_array, resources_params
+        def insert_resources_params_in_tokens_array(tokens_array, resources_params)
           resources_params_hash = {}
           tokens_array_copy = Array.new tokens_array #copy so the original remains intact
-          if resources_params.is_a? Hash
+
+          if resources_params.is_a?(Hash)
             resources_params_hash = resources_params
           else  
-            tokens_array_copy.each_with_index { |token, index| 
+            tokens_array_copy.each_with_index do |token, index| 
               resources_params_hash[token.to_sym] = resources_params[index] unless resources_params[index].nil?
-            }
+            end
           end
+
           params_insert_positions = Array.new
           tokens_array_copy.each_with_index do |token, index|
-            params_insert_positions << { :param => resources_params_hash[token.to_sym], :position => (index + 1)} if resources_params_hash.has_key? token.to_sym
+            params_insert_positions <<  {  
+                                          :param => resources_params_hash[token.to_sym], 
+                                          :position => (index + 1)
+                                        } if resources_params_hash.has_key? token.to_sym
           end
 
           params_insert_positions.inject(0) do |insert_offset,insert_position_hash|
             insert_position = insert_position_hash[:position] + insert_offset
             tokens_array_copy.insert(insert_position, insert_position_hash[:param].to_s)
-            insert_offset = insert_offset + 1
+            insert_offset + 1
           end
 
           tokens_array_copy

data/lib/rest_api/custom_api_method_call.rb

@@ -15,8 +15,8 @@ module RestApi
   # RestApi.request.get_boss_from_offices -> GET "<APIURL>/offices/boss"
   # RestApi.request.get_boss_from_offices(:resources_params => { :offices => 5} ) -> GET "<APIURL>/offices/5/boss"
 
-  def self.map_custom_api_method request_type, request_resources
-    array_resources_names = API::RequestParser.get_url_tokens_from_method request_resources
+  def self.map_custom_api_method(request_type, request_resources)
+    array_resources_names = API::RequestParser.get_url_tokens_from_method(request_resources)
     
     # initialize the resource map and pass to the yield
     resources_map = OpenStruct.new
@@ -31,7 +31,6 @@ module RestApi
 
     # create the method
     method_name = "#{request_type}_#{request_resources}"
-
     self.mapped_methods << method_name.to_sym
   
     RequestHandler.class_eval do
@@ -40,11 +39,11 @@ module RestApi
       end 
 
       eigenclass.class_eval do
-        # self = RestApi::RequestHandler
+        # self <- RestApi::RequestHandler eigenclass
         define_method method_name do |*arguments|
-          params = get_params_from_array_arguments arguments
+          params = get_params_from_array_arguments(arguments)
           request_url = API::RequestParser.get_url_from_map(array_resources_names, resources_map, params[:resources_params])
-          make_request request_type, request_url, params[:request_params]
+          make_request(request_type, request_url, params[:request_params])
         end
       end
     end
@@ -58,7 +57,7 @@ module RestApi
         end 
 
         eigenclass.class_eval do
-          undef_method mapped_method_id
+          undef_method(mapped_method_id)
         end
       end
     end
@@ -69,9 +68,9 @@ module RestApi
     @@mapped_methods
   end
 
-  def self.add_restful_api_methods request_resources, &block
+  def self.add_restful_api_methods(request_resources, &block)
     [:get, :put, :post, :delete].each do |request_type|
-      self.map_custom_api_method request_type, request_resources, &block
+      self.map_custom_api_method(request_type, request_resources, &block)
     end
   end
 end

data/lib/rest_api/exceptions.rb

@@ -11,7 +11,6 @@ module RestApi
       end
     end
 
-
-    class ApiConnectionException < Exception;end;
+    class ApiConnectionException < Exception; end;
   end
 end

data/lib/rest_api/request_handler/client.rb

@@ -5,29 +5,29 @@ module RestApi
   module RequestHandler
     module Client
       class << self
-        def get url, params = {}
+        def get(url, params = {})
           parse_response(RestClient.get(url, :params => params, :accept => :json))
         end
 
-        def post url, params = {}
+        def post(url, params = {})
           parse_response(RestClient.post(url, params, :accept => :json))
         end
 
-        def put url, params = {}
+        def put(url, params = {})
           parse_response(RestClient.put(url, params, :accept => :json))
         end
         
-        def delete url, params = {}
+        def delete(url, params = {})
           parse_response(RestClient.delete(url, :params => params, :accept => :json))
         end
 
-        def parse_response string_response
+        def parse_response(string_response)
           begin 
             return JSON.parse(string_response)
           rescue Exception => e
             raise RestApi::Exceptions::ParseResponseException.new(
                     :response_body => string_response,
-                    :error => e )
+                    :error => e)
           end
         end
         

data/lib/rest_api/request_handler.rb

@@ -9,18 +9,18 @@ module RestApi
       end
     end
 
-    def self.make_request request_type, request_url, request_params = nil
+    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
+            client.put(request_url, request_params)
           when :post
-            client.post request_url, request_params
+            client.post(request_url, request_params)
           when :delete
-            client.delete request_url, request_params
+            client.delete(request_url, request_params)
           when :get
-            client.get request_url, request_params
+            client.get(request_url, request_params)
           else
             raise Exception.new("Invalid request method")
         end
@@ -55,6 +55,7 @@ module RestApi
 
     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]
@@ -69,6 +70,7 @@ module RestApi
         end
         params_hash[:resources_params] = Array.new arguments
       end
+      
       params_hash.delete :request_params if params_hash[:request_params].nil?
       params_hash
     end

data/lib/rest_api/version.rb

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

data/lib/rest_api.rb

@@ -39,8 +39,4 @@ module RestApi
   def self.request_parser
     RestApi::API::RequestParser
   end
-
-
-
-
 end

data/rest_api.gemspec

@@ -5,8 +5,8 @@ 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.description   = %q{An easy to use, no configuration API client!}
+  gem.summary       = %q{An easy to use, no configuration API client!}
   gem.homepage      = "https://github.com/codus/rest_api"
 
   gem.files         = `git ls-files`.split($\)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rest_api
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-10-24 00:00:00.000000000 Z
+date: 2012-10-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -59,7 +59,7 @@ dependencies:
     - - ~>
       - !ruby/object:Gem::Version
         version: '1.6'
-description: An API client for any application!
+description: An easy to use, no configuration API client!
 email:
 - vinicius.oyama@codus.com.br
 executables: []
@@ -112,7 +112,7 @@ rubyforge_project:
 rubygems_version: 1.8.24
 signing_key: 
 specification_version: 3
-summary: An API client for any application!
+summary: An easy to use, no configuration API client!
 test_files:
 - spec/rest_api/api/request_parser_spec.rb
 - spec/rest_api/api_spec.rb