sinatra-swagger-exposer 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 60f345d0ee591c0a428d66ccfb5f5a7f2ae0e9b8
-  data.tar.gz: 4b750003265417b68303fa4f0112fbf0cb3f23a0
+  metadata.gz: 5aed90279990c755b73bdd72cada6ffa5437050f
+  data.tar.gz: b11db6f75e29d6bce33a8f158e960754a2f94289
 SHA512:
-  metadata.gz: a2f6f72e7ce27da5ebcd9b6517a81b6a9c6cb5cecbda87639d60fabd1142f58ea748315ea220dd7b4779f6bc8e982bee00af770f2a7f267492653af3fee54162
-  data.tar.gz: aadfda04a6b04980d1b875966c6886f4fac0f3a903596b88817742f9038e872fc2b2e2ba853e0c78a11623332befa08d4d4c51894b62a287a5c5f29e553ac177
+  metadata.gz: 79b57a8f5ddeb0c8d7cc8503550f5393274eec14527a1d5c23c5e123e8b6320a97b952b0945a0107e77ba143f82caaac4aa7c5106e5e39368c5d098872c1407d
+  data.tar.gz: 1a2fe99a4e7c6fd264023c952dfab82abd07f2a58f6009e1c933aa9179cf980c38f5997f860ed76d5265397a4bbf814eeede16ddff87fbabcb4a2ffb575a6e07

data/CHANGELOG.md

@@ -1,3 +1,7 @@
+# 0.3.0
+- Can now accept types as parameters
+- Accept json utf-8 content type
+
 # 0.2.0
 
 - Fix empty value returned from validation when a parameter is a String

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

@@ -0,0 +1,118 @@
+require_relative '../swagger-invalid-exception'
+require_relative '../swagger-utilities'
+require_relative 'swagger-parameter-validation-helper'
+require_relative 'swagger-type-property'
+
+module Sinatra
+
+  module SwaggerExposer
+
+    module Configuration
+
+      class SwaggerEndpointParameter
+
+        include Sinatra::SwaggerExposer::SwaggerUtilities
+        include SwaggerParameterValidationHelper
+
+        attr_reader :type, :name, :required, :default, :params, :items, :how_to_pass
+
+        # Create a new instance
+        # @param name [String] the name
+        # @param description [String] the description
+        # @param how_to_pass [String] how to pass the parameter
+        # @param required [TrueClass] if the parameter is required
+        # @param type [String] the type name
+        # @param params [Hash] parameters
+        # @param known_types [String] know custom types names
+        def initialize(name, description, how_to_pass, required, type, params, known_types)
+          unless name.is_a?(String) || name.is_a?(Symbol)
+            raise SwaggerInvalidException.new("Name [#{name}] should be a string or a symbol")
+          end
+          name = name.to_s
+          if name.empty?
+            raise SwaggerInvalidException.new('Name should not be empty')
+          end
+          @name = name
+
+          if description
+            @description = description
+          end
+
+          how_to_pass = how_to_pass.to_s
+          unless HOW_TO_PASS.include? how_to_pass
+            raise SwaggerInvalidException.new("Unknown how to pass value [#{how_to_pass}]#{list_or_none(HOW_TO_PASS, 'registered types')}")
+          end
+          @how_to_pass = how_to_pass
+
+          if @how_to_pass == HOW_TO_PASS_BODY
+            get_type(type, PRIMITIVE_TYPES + known_types)
+          else
+            get_type(type, PRIMITIVE_TYPES_FOR_NON_BODY)
+          end
+
+          unless [true, false].include? required
+            raise SwaggerInvalidException.new("Required should be a boolean instead of [#{required}]")
+          end
+          @required = required
+
+          params = white_list_params(params, PARAMS_LIST, SwaggerTypeProperty::PROPERTIES)
+          validate_params(@type == TYPE_ARRAY ? @items : @type, params)
+          @default = params[PARAMS_DEFAULT]
+          @params = params
+        end
+
+
+        # Return the swagger version
+        # @return [Hash]
+        def to_swagger
+          result = {
+              :name => @name,
+              :in => @how_to_pass,
+              :required => @required
+          }
+
+          if @type
+            if @type == TYPE_ARRAY
+              result[:type] = TYPE_ARRAY
+              if @items
+                if PRIMITIVE_TYPES.include? @items
+                  result[:items] = {:type => @items}
+                else
+                  result[:schema] = ref_to_type(@items)
+                end
+              end
+            else
+              if PRIMITIVE_TYPES.include? @type
+                result[:type] = @type
+              else
+                result[:schema] = ref_to_type(@type)
+              end
+            end
+          end
+
+          if @description
+            result[:description] = @description
+          end
+          unless @params.empty?
+            result.merge!(@params)
+          end
+
+          result
+        end
+
+        def to_s
+          {
+              :name => @name,
+              :in => @how_to_pass,
+              :required => @required,
+              :type => @type,
+              :items => @items,
+              :description => @description,
+              :params => @params,
+          }.to_json
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,64 @@
+require_relative '../swagger-utilities'
+require_relative '../swagger-invalid-exception'
+
+module Sinatra
+
+  module SwaggerExposer
+
+    module Configuration
+
+      class SwaggerEndpointResponse
+
+        include SwaggerUtilities
+
+        RESPONSE_PRIMITIVES_FILES = PRIMITIVE_TYPES + [TYPE_FILE]
+
+        def initialize(type, description, known_types)
+          get_type(type, known_types + RESPONSE_PRIMITIVES_FILES)
+          if description
+            @description = description
+          end
+        end
+
+        def to_swagger
+          result = {}
+
+          if @type
+            if @type == TYPE_ARRAY
+              schema = {:type => TYPE_ARRAY}
+              if @items
+                if RESPONSE_PRIMITIVES_FILES.include? @items
+                  schema[:items] = {:type => @items}
+                else
+                  schema[:items] = ref_to_type(@items)
+                end
+              end
+              result[:schema] = schema
+            else
+              if RESPONSE_PRIMITIVES_FILES.include? @type
+                result[:schema] = {:type => @type}
+              else
+                result[:schema] = ref_to_type(@type)
+              end
+            end
+          end
+
+          if @description
+            result[:description] = @description
+          end
+
+          result
+        end
+
+        def to_s
+          {
+              :type => @type,
+              :items => @items,
+              :description => @description,
+          }.to_json
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,88 @@
+require_relative '../swagger-invalid-exception'
+require_relative '../swagger-utilities'
+
+module Sinatra
+
+  module SwaggerExposer
+
+    module Configuration
+
+      # An endpoint
+      class SwaggerEndpoint
+
+        include Sinatra::SwaggerExposer::SwaggerUtilities
+
+        attr_reader :path, :type, :parameters
+
+        def initialize(type, sinatra_path, parameters, responses, summary, description, tags, explicit_path, produces)
+          @type = type
+          @path = swagger_path(sinatra_path, explicit_path)
+
+          @parameters = parameters
+          @responses = responses
+
+          @attributes = {}
+          if summary
+            @attributes[:summary] = summary
+          end
+          if description
+            @attributes[:description] = description
+          end
+          if tags
+            @attributes[:tags] = tags
+          end
+          if produces
+            @attributes[:produces] = produces
+          end
+        end
+
+        def to_swagger
+          result = @attributes.clone
+
+          unless @parameters.empty?
+            result[:parameters] = @parameters.collect { |parameter| parameter.to_swagger }
+          end
+
+          unless @responses.empty?
+            result[:responses] = hash_to_swagger(@responses)
+          end
+
+          result
+        end
+
+        REGEX_PATH_PARAM_MIDDLE = /\A(.*\/)\:([a-z]+)\/(.+)\z/
+        REGEX_PATH_PARAM_END = /\A(.*)\/:([a-z]+)\z/
+
+        # 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
+        end
+
+        def to_s
+          {
+              :type => @type,
+              :path => @path,
+              :attributes => @attributes,
+              :parameters => @parameters,
+              :responses => @responses,
+          }.to_json
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,72 @@
+require_relative '../swagger-invalid-exception'
+require_relative '../swagger-utilities'
+
+module Sinatra
+
+  module SwaggerExposer
+
+    module Configuration
+
+      # The info declaration
+      class SwaggerInfo
+
+        include SwaggerUtilities
+
+        def initialize(values)
+          @values = process(values, 'info', INFO_FIELDS, values)
+        end
+
+        # Known fields for the info field
+        INFO_FIELDS = {
+            :version => String,
+            :title => String,
+            :description => String,
+            :termsOfService => String,
+            :contact => {:name => String, :email => String, :url => String},
+            :license => {:name => String, :url => String},
+        }
+
+        # Recursive function
+        def process(current_hash, current_field_name, current_fields, top_level_hash)
+          result = {}
+
+          current_hash.each_pair do |current_key, current_value|
+            key_sym = current_key.to_sym
+            if current_fields.key? key_sym
+
+              field_content = current_fields[key_sym]
+              if field_content == String
+                if current_value.is_a? String
+                  result[key_sym] = current_value
+                else
+                  raise SwaggerInvalidException.new("Property [#{current_key}] value [#{current_value}] should be a String for #{current_field_name}: #{top_level_hash}")
+                end
+              else
+                if current_value.is_a? Hash
+                  sub_params = process(current_value, current_field_name, field_content, top_level_hash)
+                  if sub_params
+                    result[key_sym] = sub_params
+                  end
+                else
+                  raise SwaggerInvalidException.new("Property [#{current_key}] value [#{current_value}] should be a Hash for #{current_field_name}: #{top_level_hash}")
+                end
+              end
+            else
+              raise SwaggerInvalidException.new("Unknown property [#{current_key}] for #{current_field_name}#{list_or_none(current_fields.keys, 'values')}")
+            end
+          end
+          result.empty? ? nil : result
+        end
+
+        def to_swagger
+          @values
+        end
+
+        def to_s
+          @values.to_json
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,106 @@
+require_relative '../swagger-parameter-helper'
+
+module Sinatra
+
+  module SwaggerExposer
+
+    module Configuration
+
+      # Helper for validating parameters
+      module SwaggerParameterValidationHelper
+
+        include Sinatra::SwaggerExposer::SwaggerParameterHelper
+
+        # Validate parameters
+        # @param type [String] the parameter type
+        # @param params [Hash]
+        def validate_params(type, params)
+          validate_limit_parameters(type, params)
+          validate_length_parameters(type, params)
+        end
+
+        # Test if a parameter is a boolean
+        # @param name the parameter's name
+        # @param value value the parameter's value
+        # @return [NilClass]
+        def check_boolean(name, value)
+          unless [true, false].include? value
+            raise SwaggerInvalidException.new("Invalid boolean value [#{value}] for [#{name}]")
+          end
+        end
+
+        # Validate the limit parameters
+        # @param type [String] the parameter type
+        # @param params [Hash] the parameters
+        def validate_limit_parameters(type, params)
+          max = validate_limit_parameter(type, params, PARAMS_MAXIMUM, PARAMS_EXCLUSIVE_MAXIMUM)
+          min = validate_limit_parameter(type, 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 type [String] the parameter type
+        # @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(type, 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 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(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 type [String] the parameter type
+        # @param params [Hash] the parameters
+        def validate_length_parameters(type, params)
+          min_length = validate_length_parameter(type, params, PARAMS_MIN_LENGTH)
+          max_length = validate_length_parameter(type, 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 type [String] the parameter type
+        # @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(type, 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
+    end
+  end
+end