sinatra-swagger-exposer 0.2.0 → 0.3.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (32) hide show
  1. checksums.yaml +4 -4
  2. data/CHANGELOG.md +4 -0
  3. data/lib/sinatra/swagger-exposer/configuration/swagger-endpoint-parameter.rb +118 -0
  4. data/lib/sinatra/swagger-exposer/configuration/swagger-endpoint-response.rb +64 -0
  5. data/lib/sinatra/swagger-exposer/configuration/swagger-endpoint.rb +88 -0
  6. data/lib/sinatra/swagger-exposer/configuration/swagger-info.rb +72 -0
  7. data/lib/sinatra/swagger-exposer/configuration/swagger-parameter-validation-helper.rb +106 -0
  8. data/lib/sinatra/swagger-exposer/configuration/swagger-type-property.rb +82 -0
  9. data/lib/sinatra/swagger-exposer/configuration/swagger-type.rb +127 -0
  10. data/lib/sinatra/swagger-exposer/configuration/swagger-types.rb +51 -0
  11. data/lib/sinatra/swagger-exposer/processing/swagger-array-value-preprocessor.rb +46 -0
  12. data/lib/sinatra/swagger-exposer/processing/swagger-base-value-preprocessor.rb +48 -0
  13. data/lib/sinatra/swagger-exposer/processing/swagger-parameter-preprocessor.rb +47 -0
  14. data/lib/sinatra/swagger-exposer/processing/swagger-preprocessor-dispatcher.rb +45 -0
  15. data/lib/sinatra/swagger-exposer/processing/swagger-primitive-value-preprocessor.rb +165 -0
  16. data/lib/sinatra/swagger-exposer/processing/swagger-request-preprocessor.rb +64 -0
  17. data/lib/sinatra/swagger-exposer/processing/swagger-type-value-preprocessor.rb +37 -0
  18. data/lib/sinatra/swagger-exposer/swagger-content-creator.rb +3 -2
  19. data/lib/sinatra/swagger-exposer/swagger-exposer.rb +18 -20
  20. data/lib/sinatra/swagger-exposer/swagger-parameter-helper.rb +1 -1
  21. data/lib/sinatra/swagger-exposer/swagger-preprocessor-creator.rb +137 -0
  22. data/lib/sinatra/swagger-exposer/swagger-utilities.rb +1 -1
  23. data/lib/sinatra/swagger-exposer/version.rb +1 -1
  24. metadata +18 -10
  25. data/lib/sinatra/swagger-exposer/swagger-endpoint-parameter.rb +0 -197
  26. data/lib/sinatra/swagger-exposer/swagger-endpoint-response.rb +0 -63
  27. data/lib/sinatra/swagger-exposer/swagger-endpoint.rb +0 -94
  28. data/lib/sinatra/swagger-exposer/swagger-info.rb +0 -70
  29. data/lib/sinatra/swagger-exposer/swagger-parameter-preprocessor.rb +0 -187
  30. data/lib/sinatra/swagger-exposer/swagger-request-preprocessor.rb +0 -56
  31. data/lib/sinatra/swagger-exposer/swagger-type-property.rb +0 -72
  32. data/lib/sinatra/swagger-exposer/swagger-type.rb +0 -125
@@ -0,0 +1,165 @@
1
+ require 'date'
2
+
3
+ require_relative 'swagger-base-value-preprocessor'
4
+ require_relative '../swagger-parameter-helper'
5
+ require_relative '../swagger-invalid-exception'
6
+
7
+ module Sinatra
8
+
9
+ module SwaggerExposer
10
+
11
+ module Processing
12
+
13
+ # Validate primitive parameters
14
+ class SwaggerPrimitiveValuePreprocessor < SwaggerBaseValuePreprocessor
15
+
16
+ include Sinatra::SwaggerExposer::SwaggerParameterHelper
17
+
18
+ attr_reader :type, :params
19
+
20
+ # Initialize
21
+ # @param name [String] the name
22
+ # @param required [TrueClass] if the parameter is required
23
+ # @param type [String] the type name
24
+ # @param default [Object] the default value
25
+ # @param params [Hash] parameters
26
+ def initialize(name, required, type, default, params)
27
+ super(name, required, default)
28
+ @type = type
29
+ @params = params
30
+ end
31
+
32
+ def useful?
33
+ super ||
34
+ [TYPE_NUMBER, TYPE_INTEGER, TYPE_BOOLEAN, TYPE_DATE_TIME].include?(@type) || # Must check type
35
+ (@params.key? PARAMS_MIN_LENGTH) || (@params.key? PARAMS_MAX_LENGTH) # Must check string
36
+ end
37
+
38
+ # Dispatch method
39
+ def validate_param_value(value)
40
+ case @type
41
+ when TYPE_NUMBER
42
+ return validate_param_value_number(value)
43
+ when TYPE_INTEGER
44
+ return validate_param_value_integer(value)
45
+ when TYPE_BOOLEAN
46
+ return validate_param_value_boolean(value)
47
+ when TYPE_DATE_TIME
48
+ return validate_param_value_date_time(value)
49
+ else
50
+ return validate_param_value_string(value)
51
+ end
52
+ end
53
+
54
+ # Validate a boolean parameter
55
+ def validate_param_value_boolean(value)
56
+ if (value == 'true') || value.is_a?(TrueClass)
57
+ return true
58
+ elsif (value == 'false') || value.is_a?(FalseClass)
59
+ return false
60
+ else
61
+ raise SwaggerInvalidException.new("Parameter [#{name}] should be an boolean but is [#{value}]")
62
+ end
63
+ end
64
+
65
+ # Validate an integer parameter
66
+ def validate_param_value_integer(value)
67
+ begin
68
+ f = Float(value)
69
+ i = Integer(value)
70
+ if f == i
71
+ i
72
+ else
73
+ raise SwaggerInvalidException.new("Parameter [#{name}] should be an integer but is [#{value}]")
74
+ end
75
+ value = Integer(value)
76
+ validate_numerical_value(value)
77
+ value
78
+ rescue ArgumentError
79
+ raise SwaggerInvalidException.new("Parameter [#{name}] should be an integer but is [#{value}]")
80
+ rescue TypeError
81
+ raise SwaggerInvalidException.new("Parameter [#{name}] should be an integer but is [#{value}]")
82
+ end
83
+ end
84
+
85
+ # Validate a number parameter
86
+ def validate_param_value_number(value)
87
+ begin
88
+ value = Float(value)
89
+ validate_numerical_value(value)
90
+ return value
91
+ rescue ArgumentError
92
+ raise SwaggerInvalidException.new("Parameter [#{name}] should be a float but is [#{value}]")
93
+ rescue TypeError
94
+ raise SwaggerInvalidException.new("Parameter [#{name}] should be a float but is [#{value}]")
95
+ end
96
+ end
97
+
98
+ # Validate a numerical value
99
+ # @param value [Numeric] the value
100
+ def validate_numerical_value(value)
101
+ validate_numerical_value_internal(
102
+ value,
103
+ PARAMS_MINIMUM,
104
+ PARAMS_EXCLUSIVE_MINIMUM,
105
+ '>=',
106
+ '>')
107
+ validate_numerical_value_internal(
108
+ value,
109
+ PARAMS_MAXIMUM,
110
+ PARAMS_EXCLUSIVE_MAXIMUM,
111
+ '<=',
112
+ '<')
113
+ end
114
+
115
+ # Validate a date time parameter
116
+ def validate_param_value_date_time(value)
117
+ begin
118
+ DateTime.rfc3339(value)
119
+ rescue ArgumentError
120
+ raise SwaggerInvalidException.new("Parameter [#{name}] should be a date time but is [#{value}]")
121
+ end
122
+ end
123
+
124
+ # Validate a string parameter
125
+ def validate_param_value_string(value)
126
+ if value
127
+ validate_param_value_string_length(value, PARAMS_MIN_LENGTH, '>=')
128
+ validate_param_value_string_length(value, PARAMS_MAX_LENGTH, '<=')
129
+ end
130
+ value
131
+ end
132
+
133
+ # Validate the length of a string parameter
134
+ # @param value the value to check
135
+ # @param limit_param_name [Symbol] the param that contain the value to compare to
136
+ # @param limit_param_method [String] the comparison method to call
137
+ def validate_param_value_string_length(value, limit_param_name, limit_param_method)
138
+ if @params.key? limit_param_name
139
+ target_value = @params[limit_param_name]
140
+ unless value.length.send(limit_param_method, target_value)
141
+ raise SwaggerInvalidException.new("Parameter [#{name}] length should be #{limit_param_method} than #{target_value} but is #{value.length} for [#{value}]")
142
+ end
143
+ end
144
+ end
145
+
146
+ # Validate the value of a number
147
+ # @param value the value to check
148
+ # @param limit_param_name [Symbol] the param that contain the value to compare to
149
+ # @param exclusive_limit_param_name [Symbol] the param that indicates if the comparison is absolute
150
+ # @param limit_param_method [String] the comparison method to call
151
+ # @param exclusive_limit_param_method [String] the absolute comparison method to call
152
+ def validate_numerical_value_internal(value, limit_param_name, exclusive_limit_param_name, limit_param_method, exclusive_limit_param_method)
153
+ if @params.key? limit_param_name
154
+ target_value = @params[limit_param_name]
155
+ method_to_call = @params[exclusive_limit_param_name] ? exclusive_limit_param_method : limit_param_method
156
+ unless value.send(method_to_call, target_value)
157
+ raise SwaggerInvalidException.new("Parameter [#{name}] should be #{method_to_call} than [#{target_value}] but is [#{value}]")
158
+ end
159
+ end
160
+ end
161
+
162
+ end
163
+ end
164
+ end
165
+ end
@@ -0,0 +1,64 @@
1
+ require 'json'
2
+
3
+ require_relative '../swagger-invalid-exception'
4
+
5
+ module Sinatra
6
+
7
+ module SwaggerExposer
8
+
9
+ module Processing
10
+
11
+ # A preprocessor for a request, apply the parameters preprocessors then execute the query code
12
+ class SwaggerRequestPreprocessor
13
+
14
+ attr_reader :preprocessors_dispatchers
15
+
16
+ def initialize
17
+ @preprocessors_dispatchers = []
18
+ end
19
+
20
+ def add_dispatcher(dispatcher)
21
+ @preprocessors_dispatchers << dispatcher
22
+ end
23
+
24
+ VALID_JSON_CONTENT_TYPES = ['application/json', 'application/json; charset=utf-8']
25
+
26
+ # Run the preprocessor the call the route content
27
+ # @param app the sinatra app being run
28
+ # @params block_params [Array] the block parameters
29
+ # @param block the block containing the route content
30
+ def run(app, block_params, &block)
31
+ parsed_body = {}
32
+ if VALID_JSON_CONTENT_TYPES.include? app.env['CONTENT_TYPE']
33
+ body = app.request.body.read
34
+ unless body.empty?
35
+ begin
36
+ parsed_body = JSON.parse(body)
37
+ rescue JSON::ParserError => e
38
+ return [400, {:code => 400, :message => e.message}.to_json]
39
+ end
40
+ end
41
+ end
42
+ app.params['parsed_body'] = parsed_body
43
+ unless @preprocessors_dispatchers.empty?
44
+ @preprocessors_dispatchers.each do |preprocessor_dispatcher|
45
+ begin
46
+ preprocessor_dispatcher.process(app, parsed_body)
47
+ rescue SwaggerInvalidException => e
48
+ app.content_type :json
49
+ return [400, {:code => 400, :message => e.message}.to_json]
50
+ end
51
+ end
52
+ end
53
+ if block
54
+ # Execute the block in the context of the app
55
+ app.instance_exec(*block_params, &block)
56
+ else
57
+ ''
58
+ end
59
+ end
60
+
61
+ end
62
+ end
63
+ end
64
+ end
@@ -0,0 +1,37 @@
1
+ require_relative 'swagger-base-value-preprocessor'
2
+
3
+ module Sinatra
4
+
5
+ module SwaggerExposer
6
+
7
+ module Processing
8
+
9
+ # A preprocessor for a type parameter
10
+ class SwaggerTypeValuePreprocessor < SwaggerBaseValuePreprocessor
11
+
12
+ attr_reader :attributes_preprocessors
13
+
14
+ # Initialize
15
+ # @param name [String] the name
16
+ # @param required [TrueClass] if the parameter is required
17
+ # @param attributes_preprocessors [Array[Sinatra::SwaggerExposer::Processing::SwaggerBaseValuePreprocessor]] the attributes preprocessors
18
+ def initialize(name, required, attributes_preprocessors)
19
+ super(name, required)
20
+ @attributes_preprocessors = attributes_preprocessors
21
+ end
22
+
23
+ def useful?
24
+ super || (!(@attributes_preprocessors.empty?))
25
+ end
26
+
27
+ def validate_param_value(value)
28
+ @attributes_preprocessors.each do |attribute_preprocessor|
29
+ attribute_preprocessor.process(value)
30
+ end
31
+ value
32
+ end
33
+
34
+ end
35
+ end
36
+ end
37
+ end
@@ -25,8 +25,9 @@ module Sinatra
25
25
  result[:info] = @swagger_info.to_swagger
26
26
  end
27
27
 
28
- unless @swagger_types.empty?
29
- result[:definitions] = hash_to_swagger(@swagger_types)
28
+ swagger_types_as_swagger = @swagger_types.to_swagger
29
+ if swagger_types_as_swagger
30
+ result[:definitions] = swagger_types_as_swagger
30
31
  end
31
32
 
32
33
  unless @swagger_endpoints.empty?
@@ -1,14 +1,14 @@
1
1
  require 'sinatra/base'
2
2
  require 'json'
3
3
 
4
- require_relative 'swagger-endpoint'
5
- require_relative 'swagger-endpoint-parameter'
6
- require_relative 'swagger-endpoint-response'
7
- require_relative 'swagger-info'
8
- require_relative 'swagger-invalid-exception'
9
- require_relative 'swagger-type'
10
-
4
+ require_relative 'configuration/swagger-endpoint'
5
+ require_relative 'configuration/swagger-endpoint-parameter'
6
+ require_relative 'configuration/swagger-endpoint-response'
7
+ require_relative 'configuration/swagger-info'
8
+ require_relative 'configuration/swagger-types'
11
9
  require_relative 'swagger-content-creator'
10
+ require_relative 'swagger-invalid-exception'
11
+ require_relative 'swagger-preprocessor-creator'
12
12
 
13
13
  module Sinatra
14
14
 
@@ -20,7 +20,9 @@ module Sinatra
20
20
  app.set :swagger_current_endpoint_info, {}
21
21
  app.set :swagger_current_endpoint_parameters, {}
22
22
  app.set :swagger_current_endpoint_responses, {}
23
- app.set :swagger_types, {}
23
+ swagger_types = Sinatra::SwaggerExposer::Configuration::SwaggerTypes.new
24
+ app.set :swagger_types, swagger_types
25
+ app.set :swagger_preprocessor_creator, Sinatra::SwaggerExposer::SwaggerPreprocessorCreator.new(swagger_types)
24
26
  declare_swagger_endpoints(app)
25
27
  end
26
28
 
@@ -28,7 +30,7 @@ module Sinatra
28
30
  app.endpoint_summary 'The swagger endpoint'
29
31
  app.endpoint_tags 'swagger'
30
32
  app.get '/swagger_doc.json' do
31
- swagger_content = ::Sinatra::SwaggerExposer::SwaggerContentCreator.new(
33
+ swagger_content = Sinatra::SwaggerExposer::SwaggerContentCreator.new(
32
34
  settings.respond_to?(:swagger_info) ? settings.swagger_info : nil,
33
35
  settings.swagger_types,
34
36
  settings.swagger_endpoints
@@ -73,14 +75,14 @@ module Sinatra
73
75
  def endpoint_parameter(name, description, how_to_pass, required, type, params = {})
74
76
  parameters = settings.swagger_current_endpoint_parameters
75
77
  check_if_not_duplicate(name, parameters, 'Parameter')
76
- parameters[name] = SwaggerEndpointParameter.new(
78
+ parameters[name] = Sinatra::SwaggerExposer::Configuration::SwaggerEndpointParameter.new(
77
79
  name,
78
80
  description,
79
81
  how_to_pass,
80
82
  required,
81
83
  type,
82
84
  params,
83
- settings.swagger_types.keys)
85
+ settings.swagger_types.types_names)
84
86
  end
85
87
 
86
88
  # Define fluent endpoint dispatcher
@@ -114,23 +116,19 @@ module Sinatra
114
116
 
115
117
  # General information
116
118
  def general_info(params)
117
- set :swagger_info, SwaggerInfo.new(params)
119
+ set :swagger_info, Sinatra::SwaggerExposer::Configuration::SwaggerInfo.new(params)
118
120
  end
119
121
 
120
122
  # Declare a type
121
123
  def type(name, params)
122
- types = settings.swagger_types
123
- if types.key? name
124
- raise SwaggerInvalidException.new("Type [#{name}] already exist with value #{types[name]}")
125
- end
126
- types[name] = SwaggerType.new(name, params, settings.swagger_types.keys)
124
+ settings.swagger_types.add_type(name, params)
127
125
  end
128
126
 
129
127
  # Declare a response
130
128
  def endpoint_response(code, type = nil, description = nil)
131
129
  responses = settings.swagger_current_endpoint_responses
132
130
  check_if_not_duplicate(code, responses, 'Response')
133
- responses[code] = SwaggerEndpointResponse.new(type, description, settings.swagger_types.keys)
131
+ responses[code] = Sinatra::SwaggerExposer::Configuration::SwaggerEndpointResponse.new(type, description, settings.swagger_types.types_names)
134
132
  end
135
133
 
136
134
  def route(verb, path, options = {}, &block)
@@ -152,7 +150,7 @@ module Sinatra
152
150
  current_endpoint_info = settings.swagger_current_endpoint_info
153
151
  current_endpoint_parameters = settings.swagger_current_endpoint_parameters
154
152
  current_endpoint_responses = settings.swagger_current_endpoint_responses
155
- endpoint = SwaggerEndpoint.new(
153
+ endpoint = Sinatra::SwaggerExposer::Configuration::SwaggerEndpoint.new(
156
154
  type,
157
155
  path,
158
156
  current_endpoint_parameters.values,
@@ -166,7 +164,7 @@ module Sinatra
166
164
  current_endpoint_info.clear
167
165
  current_endpoint_parameters.clear
168
166
  current_endpoint_responses.clear
169
- endpoint.request_preprocessor
167
+ settings.swagger_preprocessor_creator.create_endpoint_processor(endpoint)
170
168
  end
171
169
 
172
170
  def set_if_not_exist(value, name)
@@ -22,6 +22,7 @@ module Sinatra
22
22
  TYPE_NUMBER = 'number'
23
23
  TYPE_PASSWORD = 'password'
24
24
  TYPE_STRING = 'string'
25
+ TYPE_ARRAY = 'array'
25
26
 
26
27
  PRIMITIVE_TYPES = [
27
28
  TYPE_INTEGER,
@@ -66,7 +67,6 @@ module Sinatra
66
67
  PARAMS_MAX_LENGTH,
67
68
  ]
68
69
 
69
-
70
70
  end
71
71
 
72
72
  end
@@ -0,0 +1,137 @@
1
+ require_relative 'swagger-utilities'
2
+ require_relative 'processing/swagger-array-value-preprocessor'
3
+ require_relative 'processing/swagger-preprocessor-dispatcher'
4
+ require_relative 'processing/swagger-primitive-value-preprocessor'
5
+ require_relative 'processing/swagger-request-preprocessor'
6
+ require_relative 'processing/swagger-type-value-preprocessor'
7
+
8
+ module Sinatra
9
+
10
+ module SwaggerExposer
11
+
12
+ # Create processor from configuration
13
+ class SwaggerPreprocessorCreator
14
+
15
+ include Sinatra::SwaggerExposer::SwaggerUtilities
16
+
17
+ # Initialize
18
+ # @param types [Sinatra::SwaggerExposer::SwaggerTypes]
19
+ def initialize(types)
20
+ @types = types
21
+ end
22
+
23
+ # Create an endpoint processor
24
+ # @param swagger_endpoint [Sinatra::SwaggerExposer::Configuration::SwaggerEndpoint] the endpoint
25
+ # @return [Sinatra::SwaggerExposer::Processing::SwaggerRequestPreprocessor]
26
+ def create_endpoint_processor(swagger_endpoint)
27
+ request_preprocessor = Sinatra::SwaggerExposer::Processing::SwaggerRequestPreprocessor.new
28
+ swagger_endpoint.parameters.each do |parameter|
29
+ preprocessor = create_value_preprocessor(parameter)
30
+ dispatcher = Sinatra::SwaggerExposer::Processing::SwaggerPreprocessorDispatcher.new(parameter.how_to_pass, preprocessor)
31
+ if dispatcher.useful?
32
+ request_preprocessor.add_dispatcher(dispatcher)
33
+ end
34
+ end
35
+ request_preprocessor
36
+ end
37
+
38
+ private
39
+
40
+ # Create a parameter preprocessor for a parameter
41
+ # @param parameter [Sinatra::SwaggerExposer::Configuration::SwaggerEndpointParameter]
42
+ def create_value_preprocessor(parameter)
43
+ type_name = parameter.type
44
+ if type_name == TYPE_ARRAY
45
+ if PRIMITIVE_TYPES.include? parameter.items
46
+ preprocessor_for_values = Sinatra::SwaggerExposer::Processing::SwaggerPrimitiveValuePreprocessor.new(
47
+ parameter.name,
48
+ false,
49
+ parameter.items,
50
+ parameter.default,
51
+ parameter.params
52
+ )
53
+ else
54
+ preprocessor_for_values = create_preprocessor_for_type(parameter.name, parameter.items, false)
55
+ end
56
+ Sinatra::SwaggerExposer::Processing::SwaggerArrayValuePreprocessor.new(parameter.name, parameter.required, preprocessor_for_values)
57
+ elsif PRIMITIVE_TYPES.include? type_name
58
+ Sinatra::SwaggerExposer::Processing::SwaggerPrimitiveValuePreprocessor.new(
59
+ parameter.name,
60
+ parameter.required,
61
+ type_name,
62
+ parameter.default,
63
+ parameter.params
64
+ )
65
+ else
66
+ create_preprocessor_for_type(parameter.name, parameter.type, parameter.required)
67
+ end
68
+ end
69
+
70
+ # Create a type parameter preprocessor for a type parameter
71
+ # @param parameter_name [String] the parameter name
72
+ # @param parameter_type [String] the parameter type
73
+ # @param parameter_required [TrueClass] if the parameter is required
74
+ # @return [Sinatra::SwaggerExposer::Processing::SwaggerTypeValuePreprocessor]
75
+ def create_preprocessor_for_type(parameter_name, parameter_type, parameter_required)
76
+ attributes_preprocessors = create_attributes_preprocessors_for_type(parameter_type)
77
+ Sinatra::SwaggerExposer::Processing::SwaggerTypeValuePreprocessor.new(
78
+ parameter_name,
79
+ parameter_required,
80
+ attributes_preprocessors
81
+ )
82
+ end
83
+
84
+ # Get attributes preprocessor for a type
85
+ # @param type_name [String] the type name
86
+ # @return [Array[Sinatra::SwaggerExposer::Processing::SwaggerPrimitiveValuePreprocessor]]
87
+ def create_attributes_preprocessors_for_type(type_name)
88
+ type = @types[type_name]
89
+ attributes_preprocessors = []
90
+ type.properties.each_pair do |property_name, property|
91
+ attributes_preprocessors <<
92
+ create_preprocessor_for_property(
93
+ property_name,
94
+ property,
95
+ type.required.include?(property.name)
96
+ )
97
+ end
98
+ if type.extends
99
+ attributes_preprocessors = attributes_preprocessors + create_attributes_preprocessors_for_type(type.extends)
100
+ end
101
+ attributes_preprocessors
102
+ end
103
+
104
+ # Create a processor for a type property
105
+ # @param type_property [Sinatra::SwaggerExposer::Configuration::SwaggerTypeProperty]
106
+ def create_preprocessor_for_property(name, type_property, required)
107
+ property_type = type_property.type
108
+ if property_type == TYPE_ARRAY
109
+ if PRIMITIVE_TYPES.include? type_property.items
110
+ preprocessor_for_values = Sinatra::SwaggerExposer::Processing::SwaggerPrimitiveValuePreprocessor.new(
111
+ name,
112
+ false,
113
+ type_property.items,
114
+ type_property.properties[:default],
115
+ type_property.properties
116
+ )
117
+ else
118
+ preprocessor_for_values = create_preprocessor_for_type(name, type_property.items, false)
119
+ end
120
+ Sinatra::SwaggerExposer::Processing::SwaggerArrayValuePreprocessor.new(name, required, preprocessor_for_values)
121
+ elsif PRIMITIVE_TYPES.include? property_type
122
+ Sinatra::SwaggerExposer::Processing::SwaggerPrimitiveValuePreprocessor.new(
123
+ name,
124
+ required,
125
+ property_type,
126
+ type_property.properties[:default],
127
+ type_property.properties
128
+ )
129
+ else
130
+ create_preprocessor_for_type(name, property_type, required)
131
+ end
132
+ end
133
+
134
+ end
135
+
136
+ end
137
+ end