sinatra-swagger-exposer 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: fa97395699d5708bb599a1793df03d11ee73cc6a
-  data.tar.gz: 8dcad9fd2667784b9a6ba79362e6109b344779d8
+  metadata.gz: 60f345d0ee591c0a428d66ccfb5f5a7f2ae0e9b8
+  data.tar.gz: 4b750003265417b68303fa4f0112fbf0cb3f23a0
 SHA512:
-  metadata.gz: ea832406300901d1975504d66725fec8669f465756c75abf68fdf8e3a58af5a3a530659acb50887c2ebceccd0b9287daf89cfc4e769a3365659b05bd53d16a76
-  data.tar.gz: 995af3f7a7e77b2ba82ef9644856d324b9f96cc8acf582f8fdd448f3f69ebcee34a44075ae1c84fd7a066bce44ea2af4fdf59fe681554a129d88e0017fbd6834
+  metadata.gz: a2f6f72e7ce27da5ebcd9b6517a81b6a9c6cb5cecbda87639d60fabd1142f58ea748315ea220dd7b4779f6bc8e982bee00af770f2a7f267492653af3fee54162
+  data.tar.gz: aadfda04a6b04980d1b875966c6886f4fac0f3a903596b88817742f9038e872fc2b2e2ba853e0c78a11623332befa08d4d4c51894b62a287a5c5f29e553ac177

data/CHANGELOG.md

@@ -1,8 +1,15 @@
+# 0.2.0
+
+- Fix empty value returned from validation when a parameter is a String
+- Added maxLength and minLength validations
+- Add produces parameter
+- Add fluent syntax
+
 # 0.1.0
 
 - Added verification and enrichment form params
 - Added type extends
-- Added validation for min and max value
+- Added validation for min and max value for numbers
 
 # 0.0.1
 

data/README.md

@@ -65,6 +65,24 @@ end
 
 The swagger json endpoint will be exposed at `/swagger_doc.json`.
 
+You can also use a more fluent variant by providing a hash to the `endpoint` method
+
+
+```ruby
+  endpoint :description => 'Base method to ping',
+           :responses { 200 => ['Status', 'Standard response']}
+           :tags 'Ping'
+  get '/' do
+    json({'status' => 'OK'})
+  end
+```
+
+The hash should contains the key `description`, `summary`, `path`, `tags`, `responses` and `params`.
+Note both `responses` and `params` takes a hash as argument `hash(param_name =>param_details)` and `hash(status_code=>res_param)`
+
+If the equivalent methods have more than one param, theses are wrapped in an array.
+
+
 ## Detailed example
 
 A more complete example is available [here](https://github.com/archiloque/sinatra-swagger-exposer/tree/master/example).

data/lib/sinatra/swagger-exposer/swagger-endpoint-parameter.rb

@@ -1,5 +1,7 @@
 require_relative 'swagger-invalid-exception'
+require_relative 'swagger-parameter-helper'
 require_relative 'swagger-parameter-preprocessor'
+require_relative 'swagger-type-property'
 require_relative 'swagger-utilities'
 
 module Sinatra
@@ -9,35 +11,7 @@ module Sinatra
     class SwaggerEndpointParameter
 
       include SwaggerUtilities
-
-      HOW_TO_PASS_BODY = 'body'
-      HOW_TO_PASS_HEADER = 'header'
-      HOW_TO_PASS_PATH = 'path'
-      HOW_TO_PASS_QUERY = 'query'
-      HOW_TO_PASS = [HOW_TO_PASS_PATH, HOW_TO_PASS_QUERY, HOW_TO_PASS_HEADER, 'formData', HOW_TO_PASS_BODY]
-
-      TYPE_INTEGER = 'integer'
-      TYPE_BOOLEAN = 'boolean'
-      TYPE_NUMBER = 'number'
-      TYPE_STRING = 'string'
-      PRIMITIVE_TYPES_FOR_NON_BODY = [TYPE_STRING, TYPE_NUMBER, TYPE_INTEGER, TYPE_BOOLEAN]
-
-      PARAMS_FORMAT = :format
-      PARAMS_DEFAULT = :default
-      PARAMS_EXAMPLE = :example
-      PARAMS_MAXIMUM = :maximum
-      PARAMS_MINIMUM = :minimum
-      PARAMS_EXCLUSIVE_MINIMUM = :exclusiveMinimum
-      PARAMS_EXCLUSIVE_MAXIMUM = :exclusiveMaximum
-      PARAMS_LIST = [
-          PARAMS_FORMAT,
-          PARAMS_DEFAULT,
-          PARAMS_EXAMPLE,
-          PARAMS_MAXIMUM,
-          PARAMS_MINIMUM,
-          PARAMS_EXCLUSIVE_MINIMUM,
-          PARAMS_EXCLUSIVE_MAXIMUM,
-      ]
+      include SwaggerParameterHelper
 
       def initialize(name, description, how_to_pass, required, type, params, known_types)
         unless name.is_a?(String) || name.is_a?(Symbol)
@@ -70,7 +44,7 @@ module Sinatra
         end
         @required = required
 
-        white_list_params(params, PARAMS_LIST)
+        params = white_list_params(params, PARAMS_LIST, SwaggerTypeProperty::PROPERTIES)
         validate_params(params)
         @params = params
       end
@@ -78,14 +52,18 @@ module Sinatra
       # Validate parameters
       # @param params [Hash]
       def validate_params(params)
-        validate_limit_parameter(params, PARAMS_MAXIMUM, PARAMS_EXCLUSIVE_MAXIMUM)
-        validate_limit_parameter(params, PARAMS_MINIMUM, PARAMS_EXCLUSIVE_MINIMUM)
+        validate_limit_parameters(params)
+        validate_length_parameters(params)
       end
 
+      # Create the corresponding SwaggerParameterPreprocessor
+      # @return [Sinatra::SwaggerExposer::SwaggerParameterPreprocessor]
       def preprocessor
         SwaggerParameterPreprocessor.new(@name, @how_to_pass, @required, @type, @params[:default], @params)
       end
 
+      # Return the swagger version
+      # @return [Hash]
       def to_swagger
         result = {
             :name => @name,
@@ -138,7 +116,7 @@ module Sinatra
 
       # Test if a parameter is a boolean
       # @param name the parameter's name
-      # @value value the parameter's value
+      # @param value value the parameter's value
       # @return [NilClass]
       def check_boolean(name, value)
         unless [true, false].include? value
@@ -146,23 +124,71 @@ module Sinatra
         end
       end
 
+      # Validate the limit parameters
+      # @param params [Hash] the parameters
+      def validate_limit_parameters(params)
+        max = validate_limit_parameter(params, PARAMS_MAXIMUM, PARAMS_EXCLUSIVE_MAXIMUM)
+        min = validate_limit_parameter(params, PARAMS_MINIMUM, PARAMS_EXCLUSIVE_MINIMUM)
+        if min && max && (max < min)
+          raise SwaggerInvalidException.new("Minimum value [#{min}] can't be more than maximum value [#{max}]")
+        end
+      end
+
       # Validate a limit param like maximum and exclusiveMaximum
       # @param params [Hash] the parameters
       # @param limit_param_name [Symbol] the limit parameter name
       # @param exclusive_limit_param_name [Symbol] the exclusive limit parameter name
       def validate_limit_parameter(params, limit_param_name, exclusive_limit_param_name)
+        parameter_value = nil
         if params.key? limit_param_name
           unless [TYPE_INTEGER, TYPE_NUMBER].include? @type
-            raise SwaggerInvalidException.new("Parameter #{limit_param_name} can only be specified for type #{TYPE_INTEGER} and #{TYPE_NUMBER} and not for [#{@type}]")
+            raise SwaggerInvalidException.new("Parameter #{limit_param_name} can only be specified for types #{TYPE_INTEGER} or #{TYPE_NUMBER} and not for [#{@type}]")
+          end
+          parameter_value = params[limit_param_name]
+          unless parameter_value.is_a? Numeric
+            raise SwaggerInvalidException.new("Parameter #{limit_param_name} must be a numeric and can not be [#{parameter_value}]")
           end
         end
 
         if params.key? exclusive_limit_param_name
-          check_boolean(PARAMS_EXCLUSIVE_MINIMUM, params[exclusive_limit_param_name])
+          check_boolean(exclusive_limit_param_name, params[exclusive_limit_param_name])
           unless params.key? limit_param_name
             raise SwaggerInvalidException.new("You can't have a #{exclusive_limit_param_name} value without a #{limit_param_name}")
           end
         end
+        parameter_value
+      end
+
+      # Validate the length parameters minLength and maxLength
+      # @param params [Hash] the parameters
+      def validate_length_parameters(params)
+        min_length = validate_length_parameter(params, PARAMS_MIN_LENGTH)
+        max_length = validate_length_parameter(params, PARAMS_MAX_LENGTH)
+
+        if min_length && max_length && (max_length < min_length)
+          raise SwaggerInvalidException.new("Minimum length #{min_length} can't be more than maximum length #{max_length}")
+        end
+      end
+
+      # Validate a length param like minLength and maxLength
+      # @param params [Hash] the parameters
+      # @param length_param_name [Symbol] the length parameter name
+      # @return [Integer] the parameter value if it is present
+      def validate_length_parameter(params, length_param_name)
+        if params.key? length_param_name
+          if @type == TYPE_STRING
+            parameter_value = params[length_param_name]
+            unless parameter_value.is_a? Integer
+              raise SwaggerInvalidException.new("Parameter #{length_param_name} must be an integer and can not be [#{parameter_value}]")
+            end
+            parameter_value
+          else
+            raise SwaggerInvalidException.new("Parameter #{length_param_name} can only be specified for type #{TYPE_STRING} and not for [#{@type}]")
+          end
+
+        else
+          nil
+        end
       end
 
     end

data/lib/sinatra/swagger-exposer/swagger-endpoint-response.rb

@@ -9,8 +9,10 @@ module Sinatra
 
       include SwaggerUtilities
 
+      RESPONSE_PRIMITIVES_FILES = PRIMITIVE_TYPES + [TYPE_FILE]
+
       def initialize(type, description, known_types)
-        get_type(type, known_types + PRIMITIVE_TYPES)
+        get_type(type, known_types + RESPONSE_PRIMITIVES_FILES)
         if description
           @description = description
         end
@@ -23,7 +25,7 @@ module Sinatra
           if @type == 'array'
             schema = {:type => 'array'}
             if @items
-              if PRIMITIVE_TYPES.include? @items
+              if RESPONSE_PRIMITIVES_FILES.include? @items
                 schema[:items] = {:type => @items}
               else
                 schema[:items] = ref_to_type(@items)
@@ -31,7 +33,7 @@ module Sinatra
             end
             result[:schema] = schema
           else
-            if PRIMITIVE_TYPES.include? @type
+            if RESPONSE_PRIMITIVES_FILES.include? @type
               result[:schema] = {:type => @type}
             else
               result[:schema] = ref_to_type(@type)

data/lib/sinatra/swagger-exposer/swagger-endpoint.rb

@@ -12,9 +12,9 @@ module Sinatra
 
       attr_reader :path, :type, :request_preprocessor
 
-      def initialize(type, path, parameters, responses, summary, description, tags)
+      def initialize(type, sinatra_path, parameters, responses, summary, description, tags, explicit_path, produces)
         @type = type
-        @path = sinatra_path_to_swagger_path(path)
+        @path = swagger_path(sinatra_path, explicit_path)
         @request_preprocessor = SwaggerRequestPreprocessor.new
 
         @parameters = parameters
@@ -37,12 +37,13 @@ module Sinatra
         if tags
           @attributes[:tags] = tags
         end
+        if produces
+          @attributes[:produces] = produces
+        end
       end
 
       def to_swagger
-        result = {
-            produces: ['application/json'],
-        }.merge(@attributes)
+        result = @attributes.clone
 
         unless @parameters.empty?
           result[:parameters] = @parameters.collect { |parameter| parameter.to_swagger }
@@ -58,14 +59,23 @@ module Sinatra
       REGEX_PATH_PARAM_MIDDLE = /\A(.*\/)\:([a-z]+)\/(.+)\z/
       REGEX_PATH_PARAM_END = /\A(.*)\/:([a-z]+)\z/
 
-      def sinatra_path_to_swagger_path(path)
-        while (m = REGEX_PATH_PARAM_MIDDLE.match(path))
-          path = "#{m[1]}{#{m[2]}}/#{m[3]}"
-        end
-        if (m = REGEX_PATH_PARAM_END.match(path))
-          path = "#{m[1]}/{#{m[2]}}"
+      # Get the endpoint swagger path
+      # @param sinatra_path the path declared in the sinatra app
+      # @param explicit_path an explicit path the user can specify
+      def swagger_path(sinatra_path, explicit_path)
+        if explicit_path
+          explicit_path
+        elsif sinatra_path.is_a? String
+          while (m = REGEX_PATH_PARAM_MIDDLE.match(sinatra_path))
+            sinatra_path = "#{m[1]}{#{m[2]}}/#{m[3]}"
+          end
+          if (m = REGEX_PATH_PARAM_END.match(sinatra_path))
+            sinatra_path = "#{m[1]}/{#{m[2]}}"
+          end
+          sinatra_path
+        else
+          raise SwaggerInvalidException.new("You need to specify a path when using a non-string path [#{sinatra_path}]")
         end
-        path
       end
 
       def to_s

data/lib/sinatra/swagger-exposer/swagger-exposer.rb

@@ -49,6 +49,11 @@ module Sinatra
       set_if_type_and_not_exist(summary, :summary, String)
     end
 
+    # Provide a path
+    def endpoint_path(path)
+      set_if_type_and_not_exist(path, :path, String)
+    end
+
     # Provide a description for the endpoint
     def endpoint_description(description)
       set_if_type_and_not_exist(description, :description, String)
@@ -56,7 +61,12 @@ module Sinatra
 
     # Provide tags for the endpoint
     def endpoint_tags(*tags)
-      set_if_type_and_not_exist(tags, :tags, nil)
+      set_if_not_exist(tags, :tags)
+    end
+
+    # Provide produces params for the endpoint
+    def endpoint_produces(*produces)
+      set_if_not_exist(produces, :produces)
     end
 
     # Define parameter for the endpoint
@@ -73,6 +83,35 @@ module Sinatra
           settings.swagger_types.keys)
     end
 
+    # Define fluent endpoint dispatcher
+    # @param params [Hash] the parameters
+    def endpoint(params)
+      params.each_pair do |param_name, param_value|
+        case param_name
+          when :summary
+            endpoint_summary param_value
+          when :description
+            endpoint_description param_value
+          when :tags
+            endpoint_tags *param_value
+          when :produces
+            endpoint_produces *param_value
+          when :path
+            endpoint_path param_value
+          when :parameters
+            param_value.each do |param, args_param|
+              endpoint_parameter param, *args_param
+            end
+          when :responses
+            param_value.each do |code, args_response|
+              endpoint_response code, *args_response
+            end
+          else
+            raise SwaggerInvalidException.new("Invalid endpoint parameter [#{param_name}]")
+        end
+      end
+    end
+
     # General information
     def general_info(params)
       set :swagger_info, SwaggerInfo.new(params)
@@ -99,8 +138,8 @@ module Sinatra
         super(verb, path, options, &block)
       else
         request_preprocessor = process_endpoint(verb.downcase, path, options)
-        super(verb, path, options) do
-          request_preprocessor.run(self, &block)
+        super(verb, path, options) do |*params|
+          request_preprocessor.run(self, params, &block)
         end
       end
     end
@@ -120,7 +159,9 @@ module Sinatra
           current_endpoint_responses.clone,
           current_endpoint_info[:summary],
           current_endpoint_info[:description],
-          current_endpoint_info[:tags])
+          current_endpoint_info[:tags],
+          current_endpoint_info[:path],
+          current_endpoint_info[:produces])
       settings.swagger_endpoints << endpoint
       current_endpoint_info.clear
       current_endpoint_parameters.clear
@@ -128,21 +169,23 @@ module Sinatra
       endpoint.request_preprocessor
     end
 
-    def set_if_type_and_not_exist(value, name, type)
-      if type
-        unless value.is_a? type
-          raise SwaggerInvalidException.new("#{name} [#{value}] should be a #{type.to_s.downcase}")
-        end
-      end
+    def set_if_not_exist(value, name)
       if settings.swagger_current_endpoint_info.key? name
-        raise SwaggerInvalidException.new("#{name} with value [#{value}] already defined: #{settings.swagger_current_endpoint_info[name]}")
+        raise SwaggerInvalidException.new("#{name} with value [#{value}] already defined: [#{settings.swagger_current_endpoint_info[name]}]")
       end
       settings.swagger_current_endpoint_info[name] = value
     end
 
+    def set_if_type_and_not_exist(value, name, type)
+      unless value.is_a? type
+        raise SwaggerInvalidException.new("#{name} [#{value}] should be a #{type.to_s.downcase}")
+      end
+      set_if_not_exist(value, name)
+    end
+
     def check_if_not_duplicate(key, values, name)
       if values.key? key
-        raise SwaggerInvalidException.new("#{name} already exist for #{key} with value #{values[key]}")
+        raise SwaggerInvalidException.new("#{name} already exist for #{key} with value [#{values[key]}]")
       end
     end
 

data/lib/sinatra/swagger-exposer/swagger-parameter-helper.rb

@@ -0,0 +1,73 @@
+module Sinatra
+
+  module SwaggerExposer
+
+    # Helper for handling the parameters
+    module SwaggerParameterHelper
+
+      HOW_TO_PASS_BODY = 'body'
+      HOW_TO_PASS_HEADER = 'header'
+      HOW_TO_PASS_PATH = 'path'
+      HOW_TO_PASS_QUERY = 'query'
+      HOW_TO_PASS = [HOW_TO_PASS_PATH, HOW_TO_PASS_QUERY, HOW_TO_PASS_HEADER, 'formData', HOW_TO_PASS_BODY]
+
+      TYPE_BOOLEAN = 'boolean'
+      TYPE_BYTE = 'byte'
+      TYPE_DATE = 'date'
+      TYPE_DOUBLE = 'double'
+      TYPE_DATE_TIME = 'dateTime'
+      TYPE_FLOAT = 'float'
+      TYPE_INTEGER = 'integer'
+      TYPE_LONG = 'long'
+      TYPE_NUMBER = 'number'
+      TYPE_PASSWORD = 'password'
+      TYPE_STRING = 'string'
+
+      PRIMITIVE_TYPES = [
+          TYPE_INTEGER,
+          TYPE_LONG,
+          TYPE_FLOAT,
+          TYPE_DOUBLE,
+          TYPE_STRING,
+          TYPE_BYTE,
+          TYPE_BOOLEAN,
+          TYPE_DATE,
+          TYPE_DATE_TIME,
+          TYPE_PASSWORD,
+      ]
+
+      TYPE_FILE = 'file'
+
+      PRIMITIVE_TYPES_FOR_NON_BODY = [TYPE_STRING, TYPE_NUMBER, TYPE_INTEGER, TYPE_BOOLEAN]
+
+      PARAMS_FORMAT = :format
+      PARAMS_DEFAULT = :default
+      PARAMS_EXAMPLE = :example
+
+      # For numbers
+      PARAMS_MINIMUM = :minimum
+      PARAMS_MAXIMUM = :maximum
+      PARAMS_EXCLUSIVE_MINIMUM = :exclusiveMinimum
+      PARAMS_EXCLUSIVE_MAXIMUM = :exclusiveMaximum
+
+      # For strings
+      PARAMS_MIN_LENGTH = :minLength
+      PARAMS_MAX_LENGTH = :maxLength
+
+      PARAMS_LIST = [
+          PARAMS_FORMAT,
+          PARAMS_DEFAULT,
+          PARAMS_EXAMPLE,
+          PARAMS_MINIMUM,
+          PARAMS_MAXIMUM,
+          PARAMS_EXCLUSIVE_MINIMUM,
+          PARAMS_EXCLUSIVE_MAXIMUM,
+          PARAMS_MIN_LENGTH,
+          PARAMS_MAX_LENGTH,
+      ]
+
+
+    end
+
+  end
+end

data/lib/sinatra/swagger-exposer/swagger-parameter-preprocessor.rb

@@ -1,4 +1,7 @@
+require 'date'
+
 require_relative 'swagger-endpoint-parameter'
+require_relative 'swagger-parameter-helper'
 require_relative 'swagger-invalid-exception'
 
 module Sinatra
@@ -8,6 +11,8 @@ module Sinatra
     # Process the parameters for validation and enrichment
     class SwaggerParameterPreprocessor
 
+      include SwaggerParameterHelper
+
       def initialize(name, how_to_pass, required, type, default, params)
         @name = name.to_s
         @how_to_pass = how_to_pass
@@ -17,22 +22,27 @@ module Sinatra
         @params = params
 
         # All headers are upcased
-        if how_to_pass == SwaggerEndpointParameter::HOW_TO_PASS_HEADER
+        if how_to_pass == HOW_TO_PASS_HEADER
           @name.upcase!
         end
       end
 
       def useful?
-        @required || (!@default.nil?) || [SwaggerEndpointParameter::TYPE_NUMBER, SwaggerEndpointParameter::TYPE_INTEGER, SwaggerEndpointParameter::TYPE_BOOLEAN].include?(@type)
+        @required ||
+            (!@default.nil?) ||
+            [TYPE_NUMBER, TYPE_INTEGER, TYPE_BOOLEAN, TYPE_DATE_TIME].include?(@type) || # Must check type
+            (@params.key? PARAMS_MIN_LENGTH) || (@params.key? PARAMS_MAX_LENGTH) # Must check string
       end
 
       def run(app, parsed_body)
         case @how_to_pass
-          when SwaggerEndpointParameter::HOW_TO_PASS_QUERY, SwaggerEndpointParameter::HOW_TO_PASS_PATH
+          when HOW_TO_PASS_PATH
+            # can't validate
+          when HOW_TO_PASS_QUERY
             check_param(app.params)
-          when SwaggerEndpointParameter::HOW_TO_PASS_HEADER
+          when HOW_TO_PASS_HEADER
             check_param(app.headers)
-          when SwaggerEndpointParameter::HOW_TO_PASS_BODY
+          when HOW_TO_PASS_BODY
             check_param(parsed_body || {})
         end
       end
@@ -50,15 +60,20 @@ module Sinatra
 
       def validate_param_value(value)
         case @type
-          when SwaggerEndpointParameter::TYPE_NUMBER
+          when TYPE_NUMBER
             return validate_param_value_number(value)
-          when SwaggerEndpointParameter::TYPE_INTEGER
+          when TYPE_INTEGER
             return validate_param_value_integer(value)
-          when SwaggerEndpointParameter::TYPE_BOOLEAN
+          when TYPE_BOOLEAN
             return validate_param_value_boolean(value)
+          when TYPE_DATE_TIME
+            return validate_param_value_date_time(value)
+          else
+            return validate_param_value_string(value)
         end
       end
 
+      # Validate a boolean parameter
       def validate_param_value_boolean(value)
         if (value == 'true') || value.is_a?(TrueClass)
           return true
@@ -69,6 +84,7 @@ module Sinatra
         end
       end
 
+      # Validate an integer parameter
       def validate_param_value_integer(value)
         begin
           f = Float(value)
@@ -88,6 +104,7 @@ module Sinatra
         end
       end
 
+      # Validate a number parameter
       def validate_param_value_number(value)
         begin
           value = Float(value)
@@ -105,24 +122,55 @@ module Sinatra
       def validate_numerical_value(value)
         validate_numerical_value_internal(
             value,
-            SwaggerEndpointParameter::PARAMS_MINIMUM,
-            SwaggerEndpointParameter::PARAMS_EXCLUSIVE_MINIMUM,
+            PARAMS_MINIMUM,
+            PARAMS_EXCLUSIVE_MINIMUM,
             '>=',
             '>')
         validate_numerical_value_internal(
             value,
-            SwaggerEndpointParameter::PARAMS_MAXIMUM,
-            SwaggerEndpointParameter::PARAMS_EXCLUSIVE_MAXIMUM,
+            PARAMS_MAXIMUM,
+            PARAMS_EXCLUSIVE_MAXIMUM,
             '<=',
             '<')
       end
 
+      # Validate a date time parameter
+      def validate_param_value_date_time(value)
+        begin
+          DateTime.rfc3339(value)
+        rescue ArgumentError
+          raise SwaggerInvalidException.new("Parameter [#{@name}] should be a date time but is [#{value}]")
+        end
+      end
+
+      # Validate a string parameter
+      def validate_param_value_string(value)
+        if value
+          validate_param_value_string_length(value, PARAMS_MIN_LENGTH, '>=')
+          validate_param_value_string_length(value, PARAMS_MAX_LENGTH, '<=')
+        end
+        value
+      end
+
+      # Validate the length of a string parameter
+      # @param value the value to check
+      # @param limit_param_name [Symbol] the param that contain the value to compare to
+      # @param limit_param_method [String] the comparison method to call
+      def validate_param_value_string_length(value, limit_param_name, limit_param_method)
+        if @params.key? limit_param_name
+          target_value = @params[limit_param_name]
+          unless value.length.send(limit_param_method, target_value)
+            raise SwaggerInvalidException.new("Parameter [#{@name}] length should be #{limit_param_method} than #{target_value} but is #{value.length} for [#{value}]")
+          end
+        end
+      end
+
       # Validate the value of a number
-      # @params value the value to check
-      # @params limit_param_name [Symbol] the param that contain the value to compare to
-      # @params exclusive_limit_param_name [Symbol] the param that indicates if the comparison is absolute
-      # @params limit_param_method [String] the comparison method to call
-      # @params exclusive_limit_param_method [String] the absolute comparison method to call
+      # @param value the value to check
+      # @param limit_param_name [Symbol] the param that contain the value to compare to
+      # @param exclusive_limit_param_name [Symbol] the param that indicates if the comparison is absolute
+      # @param limit_param_method [String] the comparison method to call
+      # @param exclusive_limit_param_method [String] the absolute comparison method to call
       def validate_numerical_value_internal(value, limit_param_name, exclusive_limit_param_name, limit_param_method, exclusive_limit_param_method)
         if @params.key? limit_param_name
           target_value = @params[limit_param_name]

data/lib/sinatra/swagger-exposer/swagger-request-preprocessor.rb

@@ -19,10 +19,14 @@ module Sinatra
         @preprocessors << preprocessor
       end
 
-      def run(app, &block)
+      # Run the preprocessor the call the route content
+      # @param app the sinatra app being run
+      # @params block_params [Array] the block parameters
+      # @param block the block containing the route content
+      def run(app, block_params, &block)
         parsed_body = {}
         if app.env['CONTENT_TYPE'] == 'application/json'
-          body = app.request.body
+          body = app.request.body.read
           unless body.empty?
             parsed_body = JSON.parse(body)
           end
@@ -40,7 +44,7 @@ module Sinatra
         end
         if block
           # Execute the block in the context of the app
-          app.instance_eval(&block)
+          app.instance_exec(*block_params, &block)
         else
           ''
         end

data/lib/sinatra/swagger-exposer/swagger-type-property.rb

@@ -10,7 +10,7 @@ module Sinatra
 
       include SwaggerUtilities
 
-      OTHER_PROPERTIES = [:example, :description, :format]
+      OTHER_PROPERTIES = [:example, :description, :format, :minLength, :maxLength]
       PROPERTIES = [:type] + OTHER_PROPERTIES
 
       def initialize(type_name, property_name, property_properties, known_types)

data/lib/sinatra/swagger-exposer/swagger-utilities.rb

@@ -1,4 +1,5 @@
 require_relative 'swagger-invalid-exception'
+require_relative 'swagger-parameter-helper'
 
 module Sinatra
 
@@ -6,18 +7,7 @@ module Sinatra
 
     module SwaggerUtilities
 
-      PRIMITIVE_TYPES = [
-          'integer',
-          'long',
-          'float',
-          'double',
-          'string',
-          'byte',
-          'boolean',
-          'date',
-          'dateTime',
-          'password',
-      ]
+      include ::Sinatra::SwaggerExposer::SwaggerParameterHelper
 
       def ref_to_type(type)
         {'$ref' => "#/definitions/#{type}"}
@@ -35,7 +25,9 @@ module Sinatra
       # @return [String]
       def type_to_s(value)
         if [TrueClass, FalseClass].include? value
-          'boolean'
+          TYPE_BOOLEAN
+        elsif value == DateTime
+          TYPE_DATE_TIME
         elsif value.is_a? Class
           value.to_s.downcase
         else
@@ -60,15 +52,20 @@ module Sinatra
       end
 
       # Validate if a parameter is in a list of available values
-      # @param params the parameter
+      # @param params [Hash] the parameters
       # @param allowed_values [Enumerable, #include?] the allowed values
-      # @return [NilClass]
-      def white_list_params(params, allowed_values)
+      # @param ignored_values [Enumerable, #include?] values to ignore
+      # @return [Hash] the filtered hash
+      def white_list_params(params, allowed_values, ignored_values = [])
+        result = {}
         params.each_pair do |key, value|
-          unless allowed_values.include? key
+          if allowed_values.include? key
+            result[key] = value
+          elsif !ignored_values.include?(key)
             raise SwaggerInvalidException.new("Unknown property [#{key}] with value [#{value}]#{list_or_none(allowed_values, 'properties')}")
           end
         end
+        result
       end
 
       def list_or_none(list, name)

data/lib/sinatra/swagger-exposer/version.rb

@@ -1,5 +1,5 @@
 module Sinatra
   module SwaggerExposer
-    VERSION = '0.1.0'
+    VERSION = '0.2.0'
   end
 end

data/sinatra-swagger-exposer.gemspec

@@ -3,6 +3,8 @@ lib = File.expand_path('../lib', __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'sinatra/swagger-exposer/version'
 
+excluded_patterns = ['test/', 'example/', '.travis.yml', '.gitignore']
+
 Gem::Specification.new do |spec|
   spec.name          = 'sinatra-swagger-exposer'
   spec.version       = Sinatra::SwaggerExposer::VERSION
@@ -13,7 +15,7 @@ Gem::Specification.new do |spec|
   spec.homepage      = 'https://github.com/archiloque/sinatra-swagger-exposer'
   spec.license       = 'MIT'
 
-  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| excluded_patterns.any?{|ep| f.start_with?(ep)}}
   spec.require_paths = ['lib']
 
   spec.add_dependency 'sinatra', '~> 1.4'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sinatra-swagger-exposer
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Julien Kirch
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-04-11 00:00:00.000000000 Z
+date: 2015-04-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sinatra
@@ -101,18 +101,12 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- ".gitignore"
-- ".travis.yml"
 - CHANGELOG.md
 - CODE_OF_CONDUCT.md
 - Gemfile
 - LICENSE.txt
 - README.md
 - Rakefile
-- example/Gemfile
-- example/Gemfile.lock
-- example/config.ru
-- example/petstore.rb
 - lib/sinatra/swagger-exposer/swagger-content-creator.rb
 - lib/sinatra/swagger-exposer/swagger-endpoint-parameter.rb
 - lib/sinatra/swagger-exposer/swagger-endpoint-response.rb
@@ -120,6 +114,7 @@ files:
 - lib/sinatra/swagger-exposer/swagger-exposer.rb
 - lib/sinatra/swagger-exposer/swagger-info.rb
 - lib/sinatra/swagger-exposer/swagger-invalid-exception.rb
+- lib/sinatra/swagger-exposer/swagger-parameter-helper.rb
 - lib/sinatra/swagger-exposer/swagger-parameter-preprocessor.rb
 - lib/sinatra/swagger-exposer/swagger-request-preprocessor.rb
 - lib/sinatra/swagger-exposer/swagger-type-property.rb
@@ -152,3 +147,4 @@ signing_key:
 specification_version: 4
 summary: Expose swagger API from your Sinatra app
 test_files: []
+has_rdoc: 

data/.gitignore

@@ -1,10 +0,0 @@
-/.bundle/
-/.yardoc
-/Gemfile.lock
-/_yardoc/
-/coverage/
-/doc/
-/pkg/
-/spec/reports/
-/tmp/
-sinatra-swagger-exposer-*.gem

data/.travis.yml

@@ -1,6 +0,0 @@
-language: ruby
-rvm:
-  - 2.2.0
-addons:
-  code_climate:
-    repo_token: 9327b6a5a4de354ce0da555d4ae4ed262ee0fa2e4d210d8fb82511eee5a2dc2f

data/example/Gemfile

@@ -1,4 +0,0 @@
-source 'https://rubygems.org'
-
-gem 'sinatra', '~> 1.4.5'
-gem 'sinatra-cross_origin', '~> 0.3.2'

data/example/Gemfile.lock

@@ -1,19 +0,0 @@
-GEM
-  remote: https://rubygems.org/
-  specs:
-    rack (1.6.0)
-    rack-protection (1.5.3)
-      rack
-    sinatra (1.4.6)
-      rack (~> 1.4)
-      rack-protection (~> 1.4)
-      tilt (>= 1.3, < 3)
-    sinatra-cross_origin (0.3.2)
-    tilt (2.0.1)
-
-PLATFORMS
-  ruby
-
-DEPENDENCIES
-  sinatra (~> 1.4.5)
-  sinatra-cross_origin (~> 0.3.2)

data/example/config.ru

@@ -1,2 +0,0 @@
-require_relative 'petstore'
-run Petstore

data/example/petstore.rb

@@ -1,145 +0,0 @@
-require 'sinatra/base'
-require 'json'
-require 'sinatra/cross_origin'
-
-require_relative '../lib/sinatra/swagger-exposer/swagger-exposer'
-
-class Petstore < Sinatra::Base
-
-  set :logging, true
-
-  register Sinatra::CrossOrigin
-  set :allow_origin, :any
-  enable :cross_origin
-
-  register Sinatra::SwaggerExposer
-
-  general_info(
-      {
-          :version => '1.0.0',
-          :title => 'Swagger Petstore',
-          :description => 'A sample API that uses a petstore as an example to demonstrate features in the swagger-2.0 specification',
-          :termsOfService => 'http://swagger.io/terms/',
-          :contact => {:name => 'Swagger API Team',
-                       :email => 'apiteam@swagger.io',
-                       :url => 'http://swagger.io'
-          },
-          :license => {
-              :name => 'Apache 2.0',
-              :url => 'http://github.com/gruntjs/grunt/blob/master/LICENSE-MIT'
-          }
-      }
-  )
-
-  type 'Error', {
-                  :required => [:code, :message],
-                  :properties => {
-                      :code => {
-                          :type => Integer,
-                          :example => 404,
-                          :description => 'The error code',
-                      },
-                      :message => {
-                          :type => String,
-                          :example => 'Pet not found',
-                          :description => 'The error message',
-                      },
-                  },
-              }
-
-
-  type 'Pet', {
-                :required => [:id, :name],
-                :properties => {
-                    :id => {
-                        :type => Integer,
-                        :format => 'int64',
-                    },
-                    :name => {
-                        :type => String,
-                        :example => 'doggie',
-                        :description => 'The pet name',
-                    },
-                    :photoUrls => {
-                        :type => [String],
-                    },
-                    :tags => {
-                        :type => [String],
-                        :description => 'The pet\'s tags',
-                    },
-                    :status => {
-                        :type => String,
-                        :description => 'pet status in the store',
-                        :example => 'sleepy',
-                    },
-                },
-            }
-  type 'Cat', {
-                # Not yet supported in swagger-ui, see https://github.com/swagger-api/swagger-js/issues/188
-                :extends => 'Pet',
-                :properties => {
-                    :fluffy => {
-                        :type => TrueClass,
-                        :description => 'is this cat fluffy ?',
-                        :example => true,
-                    },
-                },
-            }
-
-  endpoint_summary 'Finds all the pets'
-  endpoint_description 'Returns all pets from the system that the user has access to'
-  endpoint_tags 'Pets'
-  endpoint_response 200, ['Pet'], 'Standard response'
-  endpoint_parameter :size, 'The number of pets to return', :query, false, Integer,
-                     {
-                        :example => 100,
-                        :default => 20, # If the caller send no value the default value will be set in the params
-                        :maximum => 100,
-                        :minimum => 0,
-                        :exclusiveMinimum => true,
-                     }
-  get '/pets' do
-    content_type :json
-    [].to_json
-  end
-
-  endpoint_summary 'Finds all the cats'
-  endpoint_description 'Returns all cats from the system that the user has access to'
-  endpoint_tags 'Cats'
-  endpoint_response 200, ['Cat'], 'Standard response'
-  endpoint_parameter :size, 'The number of cats to return', :query, false, Integer,
-                     {
-                         :example => 100,
-                         :default => 20, # If the caller send no value the default value will be set in the params
-                         :maximum => 100,
-                         :minimum => 0,
-                         :exclusiveMinimum => true,
-                     }
-  get '/cats' do
-    content_type :json
-    [].to_json
-  end
-
-  endpoint_summary 'Finds a pet by its id'
-  endpoint_description 'Finds a pet by its id, or 404 if the user does not have access to the pet'
-  endpoint_tags 'Pets'
-  endpoint_response 200, 'Pet', 'Standard response'
-  endpoint_response 404, 'Error', 'Pet not found'
-  endpoint_parameter :id, 'The pet id', :path, true, Integer, # Will fail if a non-numerical value is used
-                     {
-                         :example => 1234,
-                     }
-  get '/pets/:id' do
-    content_type :json
-    [404, {:code => 404, :message => 'Pet not found'}.to_json]
-  end
-
-  # See https://github.com/britg/sinatra-cross_origin/issues/18
-  options '*' do
-    response.headers['Allow'] = 'HEAD,GET,PUT,POST,DELETE,OPTIONS'
-    response.headers['Access-Control-Allow-Headers'] = 'X-Requested-With, X-HTTP-Method-Override, Content-Type, Cache-Control, Accept'
-    200
-  end
-
-end
-