restapi 0.0.2 → 0.0.3

data/lib/restapi/version.rb

@@ -1,3 +1,3 @@
 module Restapi
-  VERSION = '0.0.2'
+  VERSION = '0.0.3'
 end

data/restapi.gemspec

@@ -18,5 +18,5 @@ Gem::Specification.new do |s|
 
   s.add_development_dependency "rspec-rails"
   s.add_development_dependency "rcov"
-  s.add_runtime_dependency "rest-client"
+  #s.add_runtime_dependency "rest-client"
 end

data/spec/controllers/users_controller_spec.rb

@@ -6,14 +6,18 @@ describe UsersController do
     it "should be described" do
       a = Restapi.get_resource_description(UsersController)
       
+      #puts Restapi.method_descriptions['users#show'].inspect
       a._short_description.should eq('Site members')
-      # a._full_description.should eq("\n<h2 id=\"label-Long+description\">Long description</h2>\n\n<p>Example resource for rest api documentation</p>\n")
-      a._methods.should eq(["users#show", "users#create", "users#index"])
-      md = a._params[:id]
+      a._methods.count.should == 4
+      a._methods.should include("users#show")
+      a._methods.should include("users#create")
+      a._methods.should include("users#index")
+      a._methods.should include("users#two_urls")
+      md = a._params_ordered.find { |p| p.name == :id }
       md.should_not be(nil)
       md.name.should eq(:id)
       md.desc.should eq("\n<p>User ID</p>\n")
-      md.required.should eq(true)
+      md.required.should eq(false)
       md.validator.class.should eq(Restapi::Validator::TypeValidator)
       a._id.should eq('users')
       a._path.should eq('/users')
@@ -46,15 +50,17 @@ describe UsersController do
       a.should eq(b)
 
       a.method.should eq(:show)
-      a.resource.should eq('users')
+      a.resource._id.should eq('users')
       a.errors[0].code.should eq(401)
       a.errors[0].description.should eq("Unauthorized")
       a.errors[1].code.should eq(404)
       a.errors[1].description.should eq("Not Found")
 
-      a.short_description.should eq("Show user profile")
-      a.path.should eq("/users/:id")
-      a.http.should eq("GET")
+      a.apis.count.should == 1
+      a.apis.first.short_description.should eq("Show user profile")
+      a.apis.first.api_url.should
+        eq("#{Restapi.configuration.api_base_url}/users/:id")
+      a.apis.first.http_method.should eq("GET")
 
       param = a.params[:session]
       param.required.should eq(true)
@@ -78,12 +84,14 @@ describe UsersController do
       param.desc.should eq("\n<p>regexp param</p>\n")
       param.required.should eq(false)
       param.validator.class.should be(Restapi::Validator::RegexpValidator)
-      param.validator.instance_variable_get("@regexp").should eq(/^[0-9]* years/)
+      param.validator.instance_variable_get("@regexp").should
+        eq(/^[0-9]* years/)
 
       param = a.params[:array_param]
       param.desc.should eq("\n<p>array validator</p>\n")
       param.validator.class.should be(Restapi::Validator::ArrayValidator)
-      param.validator.instance_variable_get("@array").should eq([100, "one", "two", 1, 2])
+      param.validator.instance_variable_get("@array").should
+        eq([100, "one", "two", 1, 2])
 
       param = a.params[:proc_param]
       param.desc.should eq("\n<p>proc validator</p>\n")
@@ -93,12 +101,27 @@ describe UsersController do
     end
     
     it "should yell ArgumentError if id is not a number" do
-      lambda { get :show, :id => "not a number", :session => "secret_hash" }.should raise_error(ArgumentError)
+      lambda { 
+        get :show, 
+            :id => "not a number", 
+            :session => "secret_hash"
+      }.should raise_error(ArgumentError)
     end
     
     it "should yell ArgumentError if float_param is not a float" do
-      lambda { get :show, :id => 5, :session => "secret_hash", :float_param => "234.2.34"}.should raise_error(ArgumentError)
-      lambda { get :show, :id => 5, :session => "secret_hash", :float_param => "no float here"}.should raise_error(ArgumentError)
+      lambda { 
+        get :show, 
+            :id => 5,
+            :session => "secret_hash",
+            :float_param => "234.2.34"
+      }.should raise_error(ArgumentError)
+      
+      lambda { 
+        get :show, 
+            :id => 5, 
+            :session => "secret_hash", 
+            :float_param => "no float here"
+      }.should raise_error(ArgumentError)
     end
 
     it "should understand float validator" do
@@ -109,13 +132,19 @@ describe UsersController do
     end
     
     it "should understand regexp validator" do
-      get :show, :id => 5, :session => "secret_hash", :regexp_param => "24 years"
+      get :show,
+          :id => 5,
+          :session => "secret_hash",
+          :regexp_param => "24 years"
       assert_response :success
     end
     
     it "should validate with regexp validator" do
       lambda {
-        get :show, :id => 5, :session => "secret_hash", :regexp_param => "ten years"
+        get :show,
+            :id => 5, 
+            :session => "secret_hash",
+            :regexp_param => "ten years"
       }.should raise_error(ArgumentError)
     end
     
@@ -126,23 +155,38 @@ describe UsersController do
       assert_response :success
       get :show, :id => 5, :session => "secret_hash", :array_param => 1
       assert_response :success
-      get :show, :id => 5, :session => "secret_hash", :array_param => "2"
+      get :show, :id => 5, :session => "secret_hash", :boolean_param => false
       assert_response :success
     end
     
     it "should raise ArgumentError with array validator" do
-      lambda { get :show, :id => 5, :session => "secret_hash", :array_param => "blabla" }.should
-      raise_error(ArgumentError)
+      lambda { 
+        get :show,
+            :id => 5,
+            :session => "secret_hash",
+            :array_param => "blabla"
+      }.should raise_error(ArgumentError)
       
-      lambda { get :show, :id => 5, :session => "secret_hash", :array_param => 3 }.should
-      raise_error(ArgumentError)
+      lambda {
+        get :show, 
+            :id => 5,
+            :session => "secret_hash",
+            :array_param => 3
+      }.should raise_error(ArgumentError)
     end
     
     it "should validate with Proc validator" do
-      lambda { get :show, :id => 5, :session => "secret_hash", :proc_param => "asdgsag" }.should
-      raise_error(ArgumentError)
+      lambda {
+        get :show,
+            :id => 5,
+            :session => "secret_hash",
+            :proc_param => "asdgsag"
+      }.should raise_error(ArgumentError)
       
-      get :show, :id => 5, :session => "secret_hash", :proc_param => "param value"
+      get :show,
+          :id => 5,
+          :session => "secret_hash",
+          :proc_param => "param value"
       assert_response :success
     end
     
@@ -151,25 +195,105 @@ describe UsersController do
   describe "POST create" do
     
     it "should understand hash validator" do
-      post :create, :user => { :username => "root", :password => "12345", :membership => "standard" }
+      post :create,
+           :user => { 
+             :username => "root",
+             :password => "12345",
+             :membership => "standard"
+           }
       assert_response :success
 
       a = Restapi[UsersController, :create]
-      a.short_description.should eq("Create user")
-      a.path.should eq("/users")
-      a.http.should eq("POST")
+      a.apis.count.should == 1
+      api = a.apis.first
+      api.short_description.should eq("Create user")
+      api.api_url.should eq("/api/users")
+      api.http_method.should eq("POST")
 
-      lambda { post :create, :user => { :username => "root", :password => "12345", :membership => "____" } }.should
-      raise_error(ArgumentError)
+      lambda {
+        post :create,
+             :user => {
+               :username => "root",
+               :password => "12345",
+               :membership => "____"
+              }
+      }.should raise_error(ArgumentError)
 
-      lambda { post :create, :user => { :username => "root" } }.should
-      raise_error(ArgumentError)
+      lambda {
+        post :create,
+             :user => { :username => "root" }
+      }.should raise_error(ArgumentError)
 
-      post :create, :user => { :username => "root", :password => "pwd" }
+      post :create, 
+           :user => { :username => "root", :password => "pwd" }
       assert_response :success
 
     end
 
+    it "it should support Hash validator without specifying keys" do
+      Restapi[UsersController, :create].to_json[:params].should include(:name => "facts",
+                                                                        :validator => "Parameter has to be Hash.",
+                                                                        :description => "\n<p>Additional optional facts about the user</p>\n",
+                                                                        :required => false)
+    end
+
+  end
+
+  describe 'two_urls' do
+
+    it "should store all api method description" do
+      method_description = Restapi[UsersController, :two_urls]
+      method_description.class.should be(Restapi::MethodDescription)
+      method_description.apis.count.should == 2
+      apis = method_description.apis
+      a1 = apis.first
+      a2 = apis.second
+      
+      a1.short_description.should eq('Get company users')
+      a1.api_url.should eq('/api/company_users')
+      a1.http_method.should eq('GET')
+      a2.short_description.should eq('Get users working in given company')
+      a2.api_url.should eq('/api/company/:id/users')
+      a2.http_method.should eq('GET')
+    end
+  
+    it "should be described by valid json" do
+       json_hash = {
+        :errors => [],
+        :doc_url => "#{Restapi.configuration.doc_base_url}#users/two_urls",
+        :full_description => '',
+        :params => [{:required=>false,
+                     :validator=>"Parameter has to be String.",
+                     :description=>"\n<p>Authorization</p>\n", :name=>"oauth"},
+                    {:required=>true,
+                     :validator=>"Parameter has to be String.",
+                     :description=>"\n<p>Username for login</p>\n",
+                     :name=>"resource_param[username]"},
+                    {:required=>true,
+                     :validator=>"Parameter has to be String.",
+                     :description=>"\n<p>Password for login</p>\n",
+                     :name=>"resource_param[password]"},
+                    {:required=>false, :validator=>"Parameter has to be Integer.",
+                     :description=>"\n<p>Company ID</p>\n",
+                     :name=>"id"},
+       ],
+        :name => :two_urls,
+        :apis => [
+          {
+            :http_method => 'GET',
+            :short_description => 'Get company users',
+            :api_url => "#{Restapi.configuration.api_base_url}/company_users"
+          },{
+            :http_method => 'GET',
+            :short_description => 'Get users working in given company',
+            :api_url =>"#{Restapi.configuration.api_base_url}/company/:id/users"
+          }
+        ]
+      }
+      
+      Restapi[UsersController, :two_urls].to_json.should eq(json_hash)
+    end
+
   end
 
 end

data/spec/dummy/app/controllers/application_controller.rb

@@ -1,3 +1,8 @@
 class ApplicationController < ActionController::Base
+  
+  resource_description do
+    param :oauth, String, :desc => "Authorization", :required => false
+  end
+
   protect_from_forgery
 end

data/spec/dummy/app/controllers/dogs_controller.rb

@@ -9,8 +9,6 @@ class DogsController < ApplicationController
   def show
     render :nothing => true
   end
-  
-  #############################################################################
 
   api :desc => "List all dogs",
       :path => "/dogs",

data/spec/dummy/app/controllers/users_controller.rb

@@ -5,7 +5,11 @@ class UsersController < ApplicationController
     short 'Site members'
     path '/users'
     version '1.0 - 3.4.2012'
-    param :id, Fixnum, :desc => "User ID", :required => true
+    param :id, Fixnum, :desc => "User ID", :required => false
+    param :resource_param, Hash, :desc => 'Param description for all methods' do
+      param :username, String, :desc => "Username for login", :required => true
+      param :password, String, :desc => "Password for login", :required => true
+    end
     description <<-EOS
       == Long description
 
@@ -43,6 +47,7 @@ class UsersController < ApplicationController
   param :float_param, Float, :desc => "float param"
   param :regexp_param, /^[0-9]* years/, :desc => "regexp param"
   param :array_param, [100, "one", "two", 1, 2], :desc => "array validator"
+  param :boolean_param, [true, false], :desc => "array validator with boolean"
   param :proc_param, lambda { |val| 
     val == "param value" ? true : "The only good value is 'param value'."
   }, :desc => "proc validator"
@@ -191,6 +196,7 @@ class UsersController < ApplicationController
     param :password, String, :desc => "Password for login", :required => true
     param :membership, ["standard","premium"], :desc => "User membership"
   end
+  param :facts, Hash, :desc => "Additional optional facts about the user"
   def create
     render :text => "OK"
   end
@@ -201,11 +207,20 @@ class UsersController < ApplicationController
   error :code => 401, :desc => "Unauthorized"
   error :code => 404, :desc => "Not Found"
   desc "List all users."
+  param :oauth, nil,
+        :desc => "Hide this global param (eg dont need auth here)"
   def index
     render :text => "List of users"
   end
-  
-  def doc
-    @api = Restapi['users', :show]
+
+  api :desc => 'Get company users',
+      :path => '/company_users',
+      :method => 'GET'
+  api :desc => 'Get users working in given company',
+      :path => '/company/:id/users',
+      :method => 'GET'
+  param :id, Integer, :desc => "Company ID"
+  def two_urls
+    render :text => 'List of users'
   end
-end
+end

data/spec/dummy/config/database.yml

@@ -11,9 +11,8 @@ development:
 # Do not set this db to the same as development or production.
 test:
   adapter: sqlite3
-  database: db/test.sqlite3
-  pool: 5
-  timeout: 5000
+  database: ":memory:"
+  timeout: 500
 
 production:
   adapter: sqlite3

data/spec/dummy/config/environment.rb

@@ -1,3 +1,6 @@
+# uncomment this line to test rails relative url root
+# ENV['RAILS_RELATIVE_URL_ROOT'] = '/relative/path'
+
 # Load the rails application
 require File.expand_path('../application', __FILE__)
 

data/spec/dummy/config/initializers/restapi.rb

@@ -24,8 +24,12 @@ Restapi.configure do |config|
       "Welcome aboard: You're riding Ruby on Rails!"
   EOS
   config.copyright = "© 2012 Pavel Pokorny"
-  config.doc_base_url = "/restapi"
+  config.doc_base_url = "/dokumentace"
   config.api_base_url = "/api"
-  config.markup_language = :rdoc
+  # config.markup = choose one of:
+  #   Restapi::Markup::RDoc.new [default]
+  #   Restapi::Markup::Markdown.new
+  #   Restapi::Markup::Textile.new
+  # or provide another class with to_html(text) instance method
   # config.validate = false
 end

data/spec/dummy/config/routes.rb

@@ -1,69 +1,16 @@
 Dummy::Application.routes.draw do
-  resources :users do
-    collection do
-      get :doc
-    end
-  end
   
-  resources :dogs
-  resources :twitter_example
-  
-  restapi
+  scope ENV['RAILS_RELATIVE_URL_ROOT'] || '/' do
+    
+    resources :users do
+      collection do
+        get :doc
+      end
+    end
   
-  # The priority is based upon order of creation:
-  # first created -> highest priority.
-
-  # Sample of regular route:
-  #   match 'products/:id' => 'catalog#view'
-  # Keep in mind you can assign values other than :controller and :action
-
-  # Sample of named route:
-  #   match 'products/:id/purchase' => 'catalog#purchase', :as => :purchase
-  # This route can be invoked with purchase_url(:id => product.id)
-
-  # Sample resource route (maps HTTP verbs to controller actions automatically):
-  #   resources :products
+    resources :dogs
+    resources :twitter_example
 
-  # Sample resource route with options:
-  #   resources :products do
-  #     member do
-  #       get 'short'
-  #       post 'toggle'
-  #     end
-  #
-  #     collection do
-  #       get 'sold'
-  #     end
-  #   end
-
-  # Sample resource route with sub-resources:
-  #   resources :products do
-  #     resources :comments, :sales
-  #     resource :seller
-  #   end
-
-  # Sample resource route with more complex sub-resources
-  #   resources :products do
-  #     resources :comments
-  #     resources :sales do
-  #       get 'recent', :on => :collection
-  #     end
-  #   end
-
-  # Sample resource route within a namespace:
-  #   namespace :admin do
-  #     # Directs /admin/products/* to Admin::ProductsController
-  #     # (app/controllers/admin/products_controller.rb)
-  #     resources :products
-  #   end
-
-  # You can have the root of your site routed with "root"
-  # just remember to delete public/index.html.
-  # root :to => "welcome#index"
-
-  # See how all your routes lay out with "rake routes"
-
-  # This is a legacy wild controller route that's not recommended for RESTful applications.
-  # Note: This route will make all actions in every controller accessible via GET requests.
-  # match ':controller(/:action(/:id(.:format)))'
+    restapi
+  end
 end