restapi 0.0.3 → 0.0.4

data/lib/restapi/validator.rb

@@ -12,9 +12,14 @@ module Restapi
         @param_description = param_description
       end
 
+      def self.inherited(subclass)
+        @validators ||= []
+        @validators.insert 0, subclass
+      end
+
       # find the right validator for given options
       def self.find(param_description, argument, options, block)
-        self.subclasses.each do |validator_type|
+        @validators.each do |validator_type|
           validator = validator_type.build(param_description, argument, options, block)
           return validator if validator
         end
@@ -49,6 +54,13 @@ module Restapi
         self.description
       end
 
+      # what type is expected, mostly string
+      # this information is used in cli client
+      # thor supported types — :string, :hash, :array, :numeric, or :boolean
+      def expected_type
+        'string'
+      end
+
     end
 
     # validate arguments type
@@ -57,29 +69,36 @@ module Restapi
       def initialize(param_description, argument)
         super(param_description)
         @type = argument
-        @type = Integer if @type == Fixnum
       end
 
       def validate(value)
         return false if value.nil?
-        begin
-          Kernel.send(@type.to_s, value)
-        rescue ArgumentError
-          return false
-        end
+        value.is_a? @type
       end
 
       def self.build(param_description, argument, options, block)
-        self.new(param_description, argument) if argument.is_a?(Class) && (argument != Hash || block.nil?)
+        if argument.is_a?(Class) && (argument != Hash || block.nil?)
+          self.new(param_description, argument) 
+        end
       end
 
       def error
-        "Parameter #{@param_name} expecting to be #{@type.name}, got: #{@error_value.class.name}"
+        "Parameter #{param_name} expecting to be #{@type.name}, got: #{@error_value.class.name}"
       end
 
       def description
         "Parameter has to be #{@type}."
       end
+
+      def expected_type
+        if @type.ancestors.include? Hash
+          'hash'
+        elsif @type.ancestors.include? Numeric
+          'numeric'
+        else
+          'string'
+        end
+      end
     end
 
     # validate arguments value with regular expression
@@ -99,7 +118,7 @@ module Restapi
       end
 
       def error
-        "Parameter #{@param_name} expecting to match /#{@regexp.source}/, got '#{@error_value}'"
+        "Parameter #{param_name} expecting to match /#{@regexp.source}/, got '#{@error_value}'"
       end
 
       def description
@@ -124,7 +143,7 @@ module Restapi
       end
 
       def error
-        "Parameter #{@param_name} has bad value (#{@error_value.inspect}). Expecting one of: #{@array.join(',')}."
+        "Parameter #{param_name} has bad value (#{@error_value.inspect}). Expecting one of: #{@array.join(',')}."
       end
 
       def description
@@ -148,7 +167,7 @@ module Restapi
       end
 
       def error
-        "Parameter #{@param_name} has bad value (\"#{@error_value}\"). #{@help}"
+        "Parameter #{param_name} has bad value (\"#{@error_value}\"). #{@help}"
       end
 
       def description
@@ -183,11 +202,11 @@ module Restapi
       end
 
       def error
-        "TODO"
+        "Has to be hash."
       end
 
       def description
-        "TODO"
+        "Has to be hash."
       end
 
       def param(param_name, *args, &block)
@@ -196,6 +215,10 @@ module Restapi
         @hash_params_ordered << param_description
         @hash_params[param_name.to_sym] = param_description
       end
+
+      def expected_type
+        'hash'
+      end
     end
 
   end

data/lib/restapi/version.rb

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

data/lib/tasks/restapi.rake

@@ -0,0 +1,157 @@
+namespace :restapi do
+
+  desc "Generate static documentation"
+  task :static => :environment do
+
+    av = ActionView::Base.new(File.expand_path("../../../app/views", __FILE__))
+
+    av.class_eval do
+      include Restapi::RestapisHelper
+    end
+
+    Dir[File.join(Rails.root, "app", "controllers", "**","*.rb")].each {|f| load f}
+
+    doc = Restapi.to_json()[:docs]
+
+    # dir in public directory
+    dir_path = File.join(::Rails.root.to_s, 'public', Restapi.configuration.doc_base_url)
+    FileUtils.rm_r(dir_path) if File.directory?(dir_path)
+    Dir.mkdir(dir_path)
+
+    copy_jscss(File.join(dir_path, Restapi.configuration.doc_base_url))
+
+    Restapi.configuration.doc_base_url = Restapi.configuration.doc_base_url[1..-1]
+    File.open(File.join(dir_path,'index.html'), "w") do |f|
+      f.write av.render(
+        :template => "restapi/restapis/static",
+        :locals => {:doc => doc},
+        :layout => 'layouts/restapi/restapi')
+      puts File.join(dir_path,'index.html')
+    end
+
+  end
+
+  def copy_jscss(dest)
+    src = File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'app', 'public', 'restapi'))
+    FileUtils.cp_r "#{src}/.", dest
+  end
+
+
+  desc "Generate CLI client for API documented with restapi gem."
+  task :client, [:api_base_url, :url_append]  => [:environment] do |t, args|
+
+    args.with_defaults :api_base_url => 'http://localhost:3000', :url_append => ''
+
+    ActiveSupport::Dependencies.autoload_paths.each do |path|
+      Dir[path + "/*.rb"].each { |file| require file }
+    end
+
+    Dir.mkdir('clients') unless File.exists?('clients')
+
+    doc = Restapi.to_json()[:docs]
+
+    create_base doc, args
+
+    create_cli doc
+  end
+
+  def ac(content, code, spaces = 0)
+    content << " "*spaces << code << "\n"
+  end
+
+  def create_base doc, args
+    content = ""
+    ac content, "require 'rubygems'"
+    ac content, "require 'weary'"
+    ac content, "require 'thread' unless defined? Mutex\n"
+    ac content, "API_BASE_URL = ENV['API_URL'] || '#{args[:api_base_url]}'"
+    ac content, "URL_APPEND = ENV['URL_APPEND'] || '#{args[:url_append]}'\n"
+
+    doc[:resources].each do |key, resource|
+
+      ac content, "class #{key.camelize}Client < Weary::Client"
+      ac content, "domain API_BASE_URL", 2
+      resource[:methods].each do |method|
+        method[:apis].each do |api|
+          ac content, "# #{api[:short_description]}", 2
+          ac content, "#{api[:http_method].downcase} :#{method[:name]}, \"#{api[:api_url]}\#{URL_APPEND}\" do |resource|", 2
+          required = []
+          optional = []
+
+          method[:params].each do |param|
+            if param[:required]
+              required << param[:name].to_sym
+            else
+              optional << param[:name].to_sym
+            end
+          end
+          ac content, "resource.optional :#{optional.join(', :')}", 4 unless optional.blank?
+          ac content, "resource.required :#{required.join(', :')}", 4 unless required.blank?
+
+          ac content, "end", 2
+        end
+      end
+      ac content, "end\n"
+    end
+
+    File.open('clients/base.rb', 'w') { |f| f.write content }
+  end
+
+  def create_cli doc
+
+    content = ""
+    ac content, "require 'rubygems'"
+    ac content, "require 'thor'"
+    ac content, "require './base'"
+
+    doc[:resources].each do |key, resource|
+      ac content, "class #{key.camelize} < Thor"
+        # ac content, "$klasses['#{key}'] = #{key.camelize}", 2
+        # ac content, "@client = RestClient::Resource.new \"\#{$API_URL}#{resource[:api_url]}\"\n", 2
+
+        ac content, "no_tasks do", 2
+        ac content, "  def client", 2
+        ac content, "    @client ||= #{key.camelize}Client.new", 2
+        ac content, "  end", 2
+        ac content, "end", 2
+
+        resource[:methods].each do |method|
+
+          method[:apis].each do |api|
+
+            params = []
+            method[:params].each do |param|
+              ac content, "method_option :#{param[:name]},", 2
+              ac content, ":required => #{param[:required] ? 'true' : 'false' },", 4
+              ac content, ":desc => '#{plaintext(param[:description])}',", 4
+              ac content, ":type => :#{param[:expected_type]}", 4
+              # :type — :string, :hash, :array, :numeric, or :boolean
+              params << param[:name]
+            end
+
+            ac content, "desc '#{method[:name]}', '#{api[:short_description]}'", 2
+            ac content, "def #{method[:name]}", 2
+            ac content, "  resp = client.#{method[:name]}(options).perform do |response|", 2
+            ac content, "    if response.success?", 2
+            ac content, "      puts response.body", 2
+            ac content, "    else", 2
+            ac content, "      puts \"status: \#{response.status}\"", 2
+            ac content, "      puts response.body", 2
+            ac content, "    end", 2
+            ac content, "  end", 2
+            ac content, "  resp.status", 2
+            ac content, "end\n", 2
+
+          end
+
+        end
+      ac content, "end\n"
+    end
+
+    File.open('clients/cli.thor', 'w') { |f| f.write content }
+  end
+
+  def plaintext(text)
+    text.gsub(/<.*?>/, '').gsub("\n",' ').strip
+  end
+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_development_dependency "weary"
 end

data/spec/controllers/restapis_controller_spec.rb

@@ -9,5 +9,89 @@ describe Restapi::RestapisController do
 
       assert_response :success
     end
+
+  end
+
+  describe "reload_controllers" do
+
+    RSpec::Matchers.define :reload_documentation do
+      match do
+        begin
+          orig = Restapi.get_resource_description("users")._short_description.dup
+          Restapi.get_resource_description("users")._short_description << 'Modified'
+          get :index
+          ret = Restapi.get_resource_description("users")._short_description == orig
+        ensure
+          Restapi.get_resource_description("users")._short_description.gsub!('Modified', "")
+        end
+      end
+
+      failure_message_for_should { "the documentation expected to be reloaded but it was not" }
+      failure_message_for_should_not { "the documentation expected not to be reloaded but it was" }
+    end
+
+    before do
+      Restapi.configuration.api_controllers_matcher = File.join(Rails.root, "app", "controllers", "**","*.rb")
+      if Restapi.configuration.send :instance_variable_defined?, "@reload_controllers"
+        Restapi.configuration.send :remove_instance_variable, "@reload_controllers"
+      end
+    end
+
+    context "it's not specified explicitly" do
+      context "and it's in development environment" do
+        before do
+          Rails.stub(:env => mock(:development? => true))
+        end
+        it { should reload_documentation }
+      end
+
+      context "and it's not development environment" do
+        it { should_not reload_documentation }
+      end
+    end
+
+
+    context "it's explicitly enabled" do
+      before do
+        Restapi.configuration.reload_controllers = true
+      end
+
+      context "and it's in development environment" do
+        before do
+          Rails.stub(:env => mock(:development? => true))
+        end
+        it { should reload_documentation }
+      end
+
+      context "and it's not development environment" do
+        it { should reload_documentation }
+      end
+    end
+
+    context "it's explicitly enabled" do
+      before do
+        Restapi.configuration.reload_controllers = false
+      end
+
+      context "and it's in development environment" do
+        before do
+          Rails.stub(:env => mock(:development? => true))
+        end
+        it { should_not reload_documentation }
+      end
+
+      context "and it's not development environment" do
+        it { should_not reload_documentation }
+      end
+    end
+
+    context "api_controllers_matcher is specified" do
+      before do
+        Restapi.configuration.reload_controllers = true
+        Restapi.configuration.api_controllers_matcher = nil
+      end
+
+      it { should_not reload_documentation }
+    end
   end
 end

data/spec/controllers/users_controller_spec.rb

@@ -1,208 +1,205 @@
 require 'spec_helper'
 
-describe UsersController do
-  
-  describe "resource" 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._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(false)
-      md.validator.class.should eq(Restapi::Validator::TypeValidator)
-      a._id.should eq('users')
-      a._path.should eq('/users')
-      a._version.should eq('1.0 - 3.4.2012')
-      a._name.should eq('Members')
+def compare_hashes(h1, h2)
+  h1.each do |key, val|
+    if val.is_a? Hash
+      compare_hashes val, h2[key]
+    elsif val.is_a? Array
+      val.each_with_index do |v, i|
+        compare_hashes val[i], h2[key][i]
+      end
+    else
+      val.should eq(h2[key])
     end
   end
+end
 
-  describe "GET show" do
+describe UsersController do
 
-    it "find a user with id" do
-      get :show, :id => 5, :session => "secret_hash"
-      
-      assert_response :success
+  describe "resource description" do
+    subject { a = Restapi.get_resource_description(UsersController) }
+
+    it "should contain all resource methods" do
+      methods = subject._methods
+      methods.count.should == 4
+      methods.should include("users#show")
+      methods.should include("users#create")
+      methods.should include("users#index")
+      methods.should include("users#two_urls")
     end
 
-    it "throw ArgumentError if some required parameter missing" do
-      lambda { get :show, :id => 5 }.should raise_error(ArgumentError)
+    it "should contain info about resource" do
+      subject._short_description.should eq('Site members')
+      subject._id.should eq('users')
+      subject._path.should eq('/users')
+      subject._version.should eq('1.0 - 3.4.2012')
+      subject._name.should eq('Members')
     end
-    
-    it "responds with status 401 if session is wrong" do
-      get :show, :id => 5, :session => "bad_hash"
-      assert_response 401
+
+    it "should contain params defined on resource level" do
+      subject._params_ordered.count.should == 2
+      p = subject._params_ordered.first
+      p.should_not be(nil)
+      p.name.should eq(:id)
+      p.desc.should eq("\n<p>User ID</p>\n")
+      p.required.should eq(false)
+      p.validator.class.should eq(Restapi::Validator::IntegerValidator)
+
+      p = subject._params_ordered.second
+      p.should_not be(nil)
+      p.name.should eq(:resource_param)
+      p.desc.should eq("\n<p>Param description for all methods</p>\n")
+      p.required.should eq(false)
+      p.validator.class.should eq(Restapi::Validator::HashValidator)
     end
+  end
 
-    it "should be annotated" do
-      
-      a = Restapi.get_method_description(UsersController, :show)
-      b = Restapi[UsersController, :show]
-      a.should eq(b)
+  describe "validators" do
 
-      a.method.should eq(:show)
-      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")
+    context "validations are disabled" do
+      before { Restapi.configuration.validate = false }
 
-      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")
+      it "should reply to valid request" do
+        get :show, :id => '5', :session => "secret_hash"
+        assert_response :success
+      end
 
-      param = a.params[:session]
-      param.required.should eq(true)
-      param.desc.should eq("\n<p>user is logged in</p>\n")
-      param.validator.class.should be(Restapi::Validator::TypeValidator)
-      param.validator.instance_variable_get("@type").should eq(String)
-      
-      param = a.params[:float_param]
-      param.required.should eq(false)
-      param.desc.should eq("\n<p>float param</p>\n")
-      param.validator.class.should be(Restapi::Validator::TypeValidator)
-      param.validator.instance_variable_get("@type").should eq(Float)
+      it "should pass if required parameter is missing" do
+        lambda { get :show, :id => 5 }.should_not raise_error
+      end
 
-      param = a.params[:id]
-      param.required.should eq(true)
-      param.desc.should eq("\n<p>user id</p>\n")
-      param.validator.class.should be(Restapi::Validator::TypeValidator)
-      param.validator.instance_variable_get("@type").should eq(Integer)
+    end
 
-      param = a.params[:regexp_param]
-      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 = 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])
+    context "validations are enabled" do
+      before { Restapi.configuration.validate = true }
 
-      param = a.params[:proc_param]
-      param.desc.should eq("\n<p>proc validator</p>\n")
-      param.validator.class.should be(Restapi::Validator::ProcValidator)
-      
-      a.full_description.length.should be > 400
-    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)
-    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)
-    end
+      it "should reply to valid request" do
+        get :show, :id => '5', :session => "secret_hash"
+        assert_response :success
+      end
 
-    it "should understand float validator" do
-      get :show, :id => 5, :session => "secret_hash", :float_param => "234.34"
-      assert_response :success
-      get :show, :id => 5, :session => "secret_hash", :float_param => "234"
-      assert_response :success
-    end
-    
-    it "should understand regexp validator" do
-      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"
-      }.should raise_error(ArgumentError)
-    end
-    
-    it "should validate with array validator" do
-      get :show, :id => 5, :session => "secret_hash", :array_param => "one"
-      assert_response :success
-      get :show, :id => 5, :session => "secret_hash", :array_param => "two"
-      assert_response :success
-      get :show, :id => 5, :session => "secret_hash", :array_param => 1
-      assert_response :success
-      get :show, :id => 5, :session => "secret_hash", :boolean_param => false
-      assert_response :success
-    end
-    
-    it "should raise ArgumentError with array validator" do
-      lambda { 
+      it "should fail if required parameter is missing" do
+        lambda { get :show, :id => 5 }.should raise_error(ArgumentError, / session /)
+      end
+
+      it "should work with Type validator" do
+        lambda {
+          get :show,
+              :id => "not a number",
+              :session => "secret_hash"
+        }.should raise_error(ArgumentError, / id /)
+      end
+
+      it "should work with Regexp validator" do
         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)
-    end
-    
-    it "should validate with Proc validator" do
-      lambda {
+            :regexp_param => "24 years"
+        assert_response :success
+
+        lambda {
+          get :show,
+              :id => 5,
+              :session => "secret_hash",
+              :regexp_param => "ten years"
+        }.should raise_error(ArgumentError, / regexp_param /)
+      end
+
+      it "should work with Array validator" do
+        get :show, :id => 5, :session => "secret_hash", :array_param => "one"
+        assert_response :success
+        get :show, :id => 5, :session => "secret_hash", :array_param => "two"
+        assert_response :success
+        get :show, :id => 5, :session => "secret_hash", :array_param => 1
+        assert_response :success
+        get :show, :id => 5, :session => "secret_hash", :boolean_param => false
+        assert_response :success
+
+        lambda {
+          get :show,
+              :id => 5,
+              :session => "secret_hash",
+              :array_param => "blabla"
+        }.should raise_error(ArgumentError, / array_param /)
+
+        lambda {
+          get :show,
+              :id => 5,
+              :session => "secret_hash",
+              :array_param => 3
+        }.should raise_error(ArgumentError, / array_param /)
+      end
+
+      it "should work with Proc validator" do
+        lambda {
+          get :show,
+              :id => 5,
+              :session => "secret_hash",
+              :proc_param => "asdgsag"
+        }.should raise_error(ArgumentError, / proc_param /)
+
         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"
-      assert_response :success
+            :proc_param => "param value"
+        assert_response :success
+      end
+
+      it "should work with Hash validator" do
+        post :create, :user => { :username => "root", :password => "12345", :membership => "standard" }
+        assert_response :success
+
+        a = Restapi[UsersController, :create]
+        param = a.params_ordered.select {|p| p.name == :user }
+        param.count.should == 1
+        param.first.validator.class.should eq(Restapi::Validator::HashValidator)
+        hash_params = param.first.validator.hash_params_ordered
+        hash_params.count.should == 3
+        hash_params[0].name == :username
+        hash_params[1].name == :password
+        hash_params[2].name == :membership
+
+        lambda {
+          post :create, :user => { :username => "root", :password => "12345", :membership => "____" }
+        }.should raise_error(ArgumentError, / membership /)
+
+        lambda {
+          post :create, :user => { :username => "root" }
+        }.should raise_error(ArgumentError, / password /)
+
+        post :create, :user => { :username => "root", :password => "pwd" }
+        assert_response :success
+      end
+
+      it "should support Hash validator without specifying keys" do
+        params = Restapi[UsersController, :create].to_json[:params]
+        params.should include(:name => "facts",
+                              :full_name => "facts",
+                              :validator => "Parameter has to be Hash.",
+                              :description => "\n<p>Additional optional facts about the user</p>\n",
+                              :required => false,
+                              :allow_nil => true,
+                              :expected_type => "hash")
+      end
+
+      it "should allow nil when allow_nil is set to true" do
+        post :create,
+             :user => {
+               :username => "root",
+               :password => "12345",
+               :membership => "standard",
+             },
+             :facts => nil
+        assert_response :success
+      end
+
     end
-    
   end
 
-  describe "POST create" do
-    
-    it "should understand hash validator" do
-      post :create,
-           :user => { 
-             :username => "root",
-             :password => "12345",
-             :membership => "standard"
-           }
-      assert_response :success
+  describe "method description" do
 
+    it "should contain basic info about method" do
       a = Restapi[UsersController, :create]
       a.apis.count.should == 1
       api = a.apis.first
@@ -210,72 +207,90 @@ describe UsersController do
       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)
+      b = Restapi.get_method_description(UsersController, :show)
+      b.should eq(Restapi[UsersController, :show])
+      b.method.should eq(:show)
+      b.resource._id.should eq('users')
 
-      lambda {
-        post :create,
-             :user => { :username => "root" }
-      }.should raise_error(ArgumentError)
+      b.apis.count.should == 1
+      api = b.apis.first
+      api.short_description.should eq("Show user profile")
+      api.api_url.should eq("#{Restapi.configuration.api_base_url}/users/:id")
+      api.http_method.should eq("GET")
+      b.full_description.length.should be > 400
+    end
 
-      post :create, 
-           :user => { :username => "root", :password => "pwd" }
-      assert_response :success
+    it "should contain possible errors description" do
+      a = Restapi.get_method_description(UsersController, :show)
 
+      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")
     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)
+    it "should contain all params description" do
+      a = Restapi.get_method_description(UsersController, :show)
+      a.params.count.should == 8
+      a.instance_variable_get('@params_ordered').count.should == 6
     end
 
-  end
-
-  describe 'two_urls' do
-
-    it "should store all api method description" do
+    it "should contain 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, a2 = method_description.apis
+
       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 = {
+      json = Restapi[UsersController, :two_urls].to_json
+      expected_hash = {
         :errors => [],
-        :doc_url => "#{Restapi.configuration.doc_base_url}#users/two_urls",
+        :examples => [],
+        :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,
+        :params => [{:full_name=>"oauth",
+                     :required=>false,
+                     :allow_nil => false,
                      :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]"},
+                     :description=>"\n<p>Authorization</p>\n",
+                     :name=>"oauth",
+                     :expected_type=>"string"},
+                    {:validator=>"Has to be hash.",
+                     :description=>"\n<p>Param description for all methods</p>\n",
+                     :expected_type=>"hash",
+                     :allow_nil=>false,
+                     :name=>"resource_param",
+                     :required=>false,
+                     :full_name=>"resource_param",
+                     :params=>
+                      [{:required=>true,
+                        :allow_nil => false,
+                        :validator=>"Parameter has to be String.",
+                        :description=>"\n<p>Username for login</p>\n",
+                        :name=>"username", :full_name=>"resource_param[username]",
+                        :expected_type=>"string"},
+                       {:required=>true,
+                        :allow_nil => false,
+                        :validator=>"Parameter has to be String.",
+                        :description=>"\n<p>Password for login</p>\n",
+                        :name=>"password", :full_name=>"resource_param[password]",
+                        :expected_type=>"string"}
+                      ]
+                    },
                     {:required=>false, :validator=>"Parameter has to be Integer.",
+                     :allow_nil => false,
                      :description=>"\n<p>Company ID</p>\n",
-                     :name=>"id"},
+                     :name=>"id", :full_name=>"id",
+                     :expected_type=>"numeric"},
        ],
         :name => :two_urls,
         :apis => [
@@ -290,8 +305,45 @@ describe UsersController do
           }
         ]
       }
-      
-      Restapi[UsersController, :two_urls].to_json.should eq(json_hash)
+
+      compare_hashes json, expected_hash
+    end
+
+  end
+
+  describe "param description" do
+
+    it "should contain all specified information" do
+      a = Restapi.get_method_description(UsersController, :show)
+
+      param = a.params[:session]
+      param.required.should eq(true)
+      param.desc.should eq("\n<p>user is logged in</p>\n")
+      param.validator.class.should be(Restapi::Validator::TypeValidator)
+      param.validator.instance_variable_get("@type").should eq(String)
+
+      param = a.params[:id]
+      param.required.should eq(true)
+      param.desc.should eq("\n<p>user id</p>\n")
+      param.validator.class.should be(Restapi::Validator::IntegerValidator)
+      param.validator.instance_variable_get("@type").should eq(Integer)
+
+      param = a.params[:regexp_param]
+      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 = 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 = a.params[:proc_param]
+      param.desc.should eq("\n<p>proc validator</p>\n")
+      param.validator.class.should be(Restapi::Validator::ProcValidator)
     end
 
   end