restapi 0.0.2 → 0.0.3

data/lib/restapi/helpers.rb

@@ -1,7 +1,7 @@
 module Restapi
   module Helpers
-    def rdoc
-      @rdoc ||= RDoc::Markup::ToHtml.new
+    def markup_to_html(text)
+      Restapi.configuration.markup.to_html(text.strip_heredoc)
     end
 
     def full_url(path)

data/lib/restapi/markup.rb

@@ -0,0 +1,45 @@
+module Restapi
+  
+  module Markup
+    
+    class RDoc
+      
+      def initialize
+        require 'rdoc'
+        require 'rdoc/markup/to_html'
+        @rdoc ||= ::RDoc::Markup::ToHtml.new
+      end
+      
+      def to_html(text)
+        @rdoc.convert(text)
+      end
+      
+    end
+    
+    class Markdown
+      
+      def initialize
+        require 'redcarpet'
+        @redcarpet ||= ::Redcarpet::Markdown.new(::Redcarpet::Render::HTML.new)
+      end
+      
+      def to_html(text)
+        @redcarpet.render(text)
+      end
+      
+    end
+    
+    class Textile
+      
+      def initialize
+        require 'RedCloth'
+      end
+      
+      def to_html(text)
+        RedCloth.new(text).to_html
+      end
+
+    end
+
+  end
+end

data/lib/restapi/method_description.rb

@@ -1,38 +1,104 @@
+require 'set'
 module Restapi
-  
+
   class MethodDescription
-    
-    attr_reader :errors, :params, :full_description, :method, :resource, :short_description, :path, :http
+  
+    class Api
+      
+      attr_accessor :short_description, :api_url, :http_method
+      
+      def initialize(args)
+        @http_method = args[:method] || args[:http_method] || args[:http]
+        @short_description = args[:desc] || args[:short] || args[:description]
+        @api_url = create_api_url(args[:path] || args[:url])
+      end
+      
+      private
+      
+      def create_api_url(path)
+        "#{Restapi.configuration.api_base_url}#{path}"
+      end
+
+    end
+
+    attr_reader :errors, :full_description, :method, :resource, :apis
     
     def initialize(method, resource, app)
       @method = method
       @resource = resource
-      args = app.get_api_args
-      @short_description = args[:desc] || args[:short] || args[:description]
-      @path = args[:path]
-      @http = args[:method]
+      
+      @apis = app.get_api_args
+     
       desc = app.get_description || ''
-      @full_description = Restapi.rdoc.convert(desc.strip_heredoc)
+      @full_description = Restapi.markup_to_html(desc)
       @errors = app.get_errors
-      @params = app.get_params
+      @params_ordered = app.get_params
+
+      parent = @resource.controller.superclass
+      if parent != ActionController::Base
+        @parent_resource = parent.controller_name
+      end
+      @resource.add_method("#{resource._id}##{method}")
+    end
+
+    def params
+      params_ordered.reduce({}) { |h,p| h[p.name] = p; h }
+    end
+
+    def params_ordered
+      all_params = []
+      # get params from parent resource description
+      if @parent_resource
+        parent = Restapi.get_resource_description(@parent_resource)
+        merge_params(all_params, parent._params_ordered) if parent
+      end
+
+      # get params from actual resource description
+      if @resource
+        merge_params(all_params, resource._params_ordered)
+      end
+
+      merge_params(all_params, @params_ordered)
+      all_params.find_all(&:validator)
     end
     
-    def doc_url; "#{Restapi.configuration.doc_base_url}/#{@resource}/#{@method}"; end
-    def api_url; "#{Restapi.configuration.api_base_url}#{@path}"; end
+    def doc_url
+      [
+        ENV["RAILS_RELATIVE_URL_ROOT"],
+        Restapi.configuration.doc_base_url,
+        "##{@resource._id}/#{@method}"
+      ].join
+    end
+
+    def method_apis_to_json
+      @apis.each.collect do |api|
+        {
+          :api_url => api.api_url,
+          :http_method => api.http_method,
+          :short_description => api.short_description
+        }
+      end
+    end
 
     def to_json
       {
         :doc_url => doc_url,
-        :api_url => api_url,
         :name => @method,
-        :http_method => @http,
-        :short_description => @short_description,
+        :apis => method_apis_to_json,
         :full_description => @full_description,
         :errors => @errors,
-        :params => @params.collect { |_,v| v.to_json }
+        :params => params_ordered.map(&:to_json).flatten
       }
     end
 
+    private
+
+    def merge_params(params, new_params)
+      new_param_names = Set.new(new_params.map(&:name))
+      params.delete_if { |p| new_param_names.include?(p.name) }
+      params.concat(new_params)
+    end
+
   end
   
-end
+end

data/lib/restapi/param_description.rb

@@ -9,6 +9,8 @@ module Restapi
   class ParamDescription
 
     attr_reader :name, :desc, :required, :validator
+
+    attr_accessor :parent
     
     def initialize(name, *args, &block)
 
@@ -20,12 +22,15 @@ module Restapi
       options = args.pop || {}
       
       @name = name
-      @desc = Restapi.rdoc.convert((options[:desc] || '').strip_heredoc)
+      @desc = Restapi.markup_to_html(options[:desc] || '')
       @required = options[:required] || false
       
-      @validator = Validator::BaseValidator.find(validator_type, options, block)
-      raise "Validator not found." unless validator
-      @validator.param_name = @name
+      @validator = nil
+      unless validator_type.nil?
+        @validator = 
+          Validator::BaseValidator.find(self, validator_type, options, block)
+        raise "Validator not found." unless validator
+      end
     end
 
     def validate(value)
@@ -34,15 +39,35 @@ module Restapi
       end
     end
 
+    def full_name
+      name_parts = parents_and_self.map(&:name)
+      return ([name_parts.first] + name_parts[1..-1].map { |n| "[#{n}]" }).join("")
+    end
+
+    # returns an array of all the parents: starting with the root parent
+    # ending with itself
+    def parents_and_self
+      ret = []
+      if self.parent
+        ret.concat(self.parent.parents_and_self)
+      end
+      ret << self
+      ret
+    end
+
     def to_json
-      {
-        :name => name,
-        :description => desc,
-        :required => required,
-        :validator => validator.to_s
-      }
+      if validator.is_a? Restapi::Validator::HashValidator
+        validator.hash_params_ordered.map(&:to_json)
+      else
+        {
+          :name => full_name,
+          :description => desc,
+          :required => required,
+          :validator => validator.to_s
+        }
+      end
     end
 
   end
 
-end
+end

data/lib/restapi/resource_description.rb

@@ -10,12 +10,14 @@ module Restapi
   # id - resouce name
   class ResourceDescription
     
-    attr_reader :_short_description, :_full_description, :_methods, :_id, :_path, :_version, :_name, :_params
+    attr_reader :controller, :_short_description, :_full_description, :_methods, :_id,
+      :_path, :_version, :_name, :_params_ordered
     
-    def initialize(resource_name, &block)
+    def initialize(controller, resource_name, &block)
       @_methods = []
-      @_params = Hash.new
+      @_params_ordered = []
 
+      @controller = controller
       @_id = resource_name
       @_version = "1"
       @_name = @_id.humanize
@@ -25,19 +27,24 @@ module Restapi
       
       block.arity < 1 ? instance_eval(&block) : block.call(self) if block_given?
     end
-    
+
     def param(param_name, *args, &block)
-      @_params[param_name] = Restapi::ParamDescription.new(param_name, *args, &block)
+      param_description = Restapi::ParamDescription.new(param_name, *args, &block)
+      @_params_ordered << param_description
     end
     
     def path(path); @_path = path; end
+    
     def version(version); @_version = version; end
+    
     def name(name); @_name = name; end
+    
     def short(short); @_short_description = short; end
     alias :short_description :short
+    
     def desc(description)
       description ||= ''
-      @_full_description = Restapi.rdoc.convert(description.strip_heredoc)
+      @_full_description = Restapi.markup_to_html(description)
     end
     alias :description :desc
     alias :full_description :desc
@@ -48,7 +55,10 @@ module Restapi
       @_methods.uniq!
     end
     
-    def doc_url; "#{Restapi.configuration.doc_base_url}/#{@_id}"; end
+    def doc_url
+      "#{ENV["RAILS_RELATIVE_URL_ROOT"]}#{Restapi.configuration.doc_base_url}##{@_id}"
+    end
+
     def api_url; "#{Restapi.configuration.api_base_url}#{@_path}"; end
     
     def to_json(method_name = nil)
@@ -69,7 +79,5 @@ module Restapi
         :methods => _methods
       }
     end
-
   end
-  
-end
+end

data/lib/restapi/restapi_module.rb

@@ -1,7 +1,5 @@
 require "restapi/helpers"
 require "restapi/application"
-require "ostruct"
-require "erb"
 
 module Restapi
   extend Restapi::Helpers
@@ -28,14 +26,15 @@ module Restapi
   end
 
   class Configuration
-    attr_accessor :app_name, :app_info, :copyright, :markup_language, :validate, :api_base_url, :doc_base_url
-
-    def app_info=(text)
-      @app_info = Restapi.rdoc.convert(text.strip_heredoc)
+    attr_accessor :app_name, :app_info, :copyright, :markup,
+      :validate, :api_base_url, :doc_base_url
+    
+    def app_info
+      Restapi.markup_to_html(@app_info)
     end
     
     def initialize
-      @markup_language = :rdoc
+      @markup = Restapi::Markup::RDoc.new
       @app_name = "Another API"
       @app_info = "Another API description"
       @copyright = nil

data/lib/restapi/static_dispatcher.rb

@@ -46,6 +46,8 @@ module Restapi
       case env['REQUEST_METHOD']
       when 'GET', 'HEAD'
         path = env['PATH_INFO'].sub("#{@baseurl}/","/restapi/").chomp('/')
+        path.sub!("#{ENV["RAILS_RELATIVE_URL_ROOT"]}",'')
+        
         if match = @file_handler.match?(path)
           env["PATH_INFO"] = match
           return @file_handler.call(env)

data/lib/restapi/validator.rb

@@ -6,12 +6,16 @@ module Restapi
     # and implement class method build and instance method validate
     class BaseValidator
 
-      attr_accessor :param_name
+      attr_accessor :param_description
+
+      def initialize(param_description)
+        @param_description = param_description
+      end
 
       # find the right validator for given options
-      def self.find(argument, options, block)
+      def self.find(param_description, argument, options, block)
         self.subclasses.each do |validator_type|
-          validator = validator_type.build(argument, options, block)
+          validator = validator_type.build(param_description, argument, options, block)
           return validator if validator
         end
         return nil
@@ -28,6 +32,10 @@ module Restapi
         end
       end
 
+      def param_name
+        @param_description.name
+      end
+
       # validator description
       def description
         "TODO: validator description"
@@ -46,7 +54,8 @@ module Restapi
     # validate arguments type
     class TypeValidator < BaseValidator
 
-      def initialize(argument)
+      def initialize(param_description, argument)
+        super(param_description)
         @type = argument
         @type = Integer if @type == Fixnum
       end
@@ -60,8 +69,8 @@ module Restapi
         end
       end
 
-      def self.build(argument, options, block)
-        self.new(argument) if argument.is_a?(Class) && argument != Hash
+      def self.build(param_description, argument, options, block)
+        self.new(param_description, argument) if argument.is_a?(Class) && (argument != Hash || block.nil?)
       end
 
       def error
@@ -76,7 +85,8 @@ module Restapi
     # validate arguments value with regular expression
     class RegexpValidator < BaseValidator
 
-      def initialize(argument)
+      def initialize(param_description, argument)
+        super(param_description)
         @regexp = argument
       end
 
@@ -84,8 +94,8 @@ module Restapi
         value =~ @regexp
       end
 
-      def self.build(argument, options, proc)
-        self.new(argument) if argument.is_a? Regexp
+      def self.build(param_description, argument, options, proc)
+        self.new(param_description, argument) if argument.is_a? Regexp
       end
 
       def error
@@ -100,26 +110,17 @@ module Restapi
     # arguments value must be one of given in array
     class ArrayValidator < BaseValidator
 
-      def initialize(argument)
+      def initialize(param_description, argument)
+        super(param_description)
         @array = argument
       end
 
       def validate(value)
-
-        @array.find do |expected|
-          expected_class = expected.class
-          expected_class = Integer if expected_class == Fixnum
-          begin
-            converted_value = Kernel.send(expected_class.to_s, value)
-          rescue ArgumentError
-            false
-          end
-          converted_value === expected
-        end
+        @array.include?(value)
       end
 
-      def self.build(argument, options, proc)
-        self.new(argument) if argument.is_a?(Array)
+      def self.build(param_description, argument, options, proc)
+        self.new(param_description, argument) if argument.is_a?(Array)
       end
 
       def error
@@ -133,7 +134,8 @@ module Restapi
 
     class ProcValidator < BaseValidator
 
-      def initialize(argument)
+      def initialize(param_description, argument)
+        super(param_description)
         @proc = argument
       end
 
@@ -141,8 +143,8 @@ module Restapi
         (@help = @proc.call(value)) === true
       end
 
-      def self.build(argument, options, proc)
-        self.new(argument) if argument.is_a?(Proc) && argument.arity == 1
+      def self.build(param_description, argument, options, proc)
+        self.new(param_description, argument) if argument.is_a?(Proc) && argument.arity == 1
       end
 
       def error
@@ -156,12 +158,16 @@ module Restapi
 
     class HashValidator < BaseValidator
 
-      def self.build(argument, options, block)
-        self.new(block) if block.is_a?(Proc) && block.arity <= 0 && argument == Hash
+      attr_reader :hash_params_ordered
+
+      def self.build(param_description, argument, options, block)
+        self.new(param_description, block) if block.is_a?(Proc) && block.arity <= 0 && argument == Hash
       end
 
-      def initialize(argument)
+      def initialize(param_description, argument)
+        super(param_description)
         @proc = argument
+        @hash_params_ordered = []
         @hash_params = {}
 
         self.instance_exec(&@proc)
@@ -185,9 +191,12 @@ module Restapi
       end
 
       def param(param_name, *args, &block)
-        @hash_params[param_name.to_sym] = Restapi::ParamDescription.new(param_name, *args, &block)
+        param_description = Restapi::ParamDescription.new(param_name, *args, &block)
+        param_description.parent = self.param_description
+        @hash_params_ordered << param_description
+        @hash_params[param_name.to_sym] = param_description
       end
     end
 
   end
-end
+end