sinatra-swagger-exposer 0.3.0 → 0.4.0

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

@@ -0,0 +1,68 @@
+require_relative '../swagger-invalid-exception'
+
+require_relative 'swagger-parameter-validation-helper'
+require_relative 'swagger-type-property'
+require_relative 'swagger-configuration-utilities'
+
+module Sinatra
+
+  module SwaggerExposer
+
+    module Configuration
+
+      class SwaggerResponseHeader
+
+        include SwaggerConfigurationUtilities
+        include SwaggerParameterValidationHelper
+
+        attr_reader :type, :name, :description
+
+        PRIMITIVE_HEADERS_TYPES = [
+          TYPE_STRING,
+          TYPE_NUMBER,
+          TYPE_INTEGER,
+          TYPE_BOOLEAN,
+        ]
+
+        # Create a new instance
+        # @param name [String] the name
+        # @param description [String] the description
+        # @param type [String] the type name
+        def initialize(name, type, description)
+          check_name(name)
+          @name = name
+
+          if description
+            @description = description
+          end
+
+          get_type(type, PRIMITIVE_HEADERS_TYPES)
+        end
+
+
+        # Return the swagger version
+        # @return [Hash]
+        def to_swagger
+          result = {
+            :type => @type,
+          }
+
+          if @description
+            result[:description] = @description
+          end
+
+          result
+        end
+
+        def to_s
+          {
+            :name => @name,
+            :type => @type,
+            :description => @description,
+          }.to_json
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+require_relative 'swagger-hash-like'
+require_relative 'swagger-response-header'
+
+module Sinatra
+
+  module SwaggerExposer
+
+    module Configuration
+
+      # Contain all the declared response headers
+      class SwaggerResponseHeaders < SwaggerHashLike
+
+        attr_reader :response_headers
+
+        def initialize
+          @response_headers = {}
+          super(@response_headers)
+        end
+
+        # Add a new swagger response header
+        # @param name [String] the type name
+        # @param type [Object] the type
+        # @param description [String] the description
+        def add_response_header(name, type, description)
+          name = name.to_s
+          check_duplicate(name, 'Response header')
+          @response_headers[name] = SwaggerResponseHeader.new(name, type, description)
+        end
+
+      end
+    end
+  end
+end

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

@@ -1,5 +1,6 @@
 require_relative '../swagger-invalid-exception'
-require_relative '../swagger-utilities'
+
+require_relative 'swagger-configuration-utilities'
 require_relative 'swagger-parameter-validation-helper'
 
 module Sinatra
@@ -12,7 +13,7 @@ module Sinatra
 
         attr_reader :name, :type, :items
 
-        include Sinatra::SwaggerExposer::SwaggerUtilities
+        include SwaggerConfigurationUtilities
         include SwaggerParameterValidationHelper
 
         OTHER_PROPERTIES = [:example, :description, :format, :minLength, :maxLength, :default]
@@ -69,10 +70,10 @@ module Sinatra
 
         def to_s
           {
-              :name => @name,
-              :type => @type,
-              :items => @items,
-              :other_properties => @other_properties,
+            :name => @name,
+            :type => @type,
+            :items => @items,
+            :other_properties => @other_properties,
           }.to_json
         end
 

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

@@ -1,5 +1,6 @@
 require_relative '../swagger-invalid-exception'
-require_relative '../swagger-utilities'
+
+require_relative 'swagger-configuration-utilities'
 require_relative 'swagger-type-property'
 
 module Sinatra
@@ -12,7 +13,7 @@ module Sinatra
 
         attr_reader :properties, :required, :extends
 
-        include Sinatra::SwaggerExposer::SwaggerUtilities
+        include SwaggerConfigurationUtilities
 
         PROPERTY_PROPERTIES = :properties
         PROPERTY_REQUIRED = :required
@@ -103,10 +104,10 @@ module Sinatra
 
           if @extends
             result = {
-                :allOf => [
-                    ref_to_type(@extends),
-                    result
-                ]
+              :allOf => [
+                ref_to_type(@extends),
+                result
+              ]
             }
           end
 
@@ -115,9 +116,9 @@ module Sinatra
 
         def to_s
           {
-              :properties => @properties,
-              :required => @required,
-              :example => @example,
+            :properties => @properties,
+            :required => @required,
+            :example => @example,
           }.to_json
         end
 

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

@@ -1,6 +1,5 @@
+require_relative 'swagger-hash-like'
 require_relative 'swagger-type'
-require_relative '../swagger-utilities'
-require_relative '../swagger-invalid-exception'
 
 module Sinatra
 
@@ -9,27 +8,20 @@ module Sinatra
     module Configuration
 
       # Contain all the declared types
-      class SwaggerTypes
+      class SwaggerTypes < SwaggerHashLike
 
         attr_reader :types
 
-        include Sinatra::SwaggerExposer::SwaggerUtilities
-
         def initialize
           @types = {}
-        end
-
-        def [](name)
-          @types[name]
+          super(types)
         end
 
         # Add a new swagger type
         # @param name [String] the type name
         # @param params [Hash] the type params
         def add_type(name, params)
-          if @types.key? name
-            raise SwaggerInvalidException.new("Type [#{name}] already exist with value #{@types[name]}")
-          end
+          check_duplicate(name, 'Type')
           @types[name] = SwaggerType.new(name, params, @types.keys)
         end
 
@@ -37,14 +29,6 @@ module Sinatra
           @types.keys
         end
 
-        def to_swagger
-          if @types.empty?
-            nil
-          else
-            hash_to_swagger(@types)
-          end
-        end
-
       end
     end
   end

data/lib/sinatra/swagger-exposer/processing/swagger-array-value-processor.rb

@@ -0,0 +1,46 @@
+require_relative '../swagger-parameter-helper'
+require_relative '../swagger-invalid-exception'
+require_relative 'swagger-base-value-processor'
+
+module Sinatra
+
+  module SwaggerExposer
+
+    module Processing
+
+      # Validate arrays
+      class SwaggerArrayValueProcessor < SwaggerBaseValueProcessor
+
+        include Sinatra::SwaggerExposer::SwaggerParameterHelper
+
+        attr_reader :processor_for_values
+
+        # Initialize
+        # @param name [String] the name
+        # @param required [TrueClass] if the parameter is required
+        # @param processor_for_values [Sinatra::SwaggerExposer::Processing::SwaggerBaseValueProcessor] processor for the values
+        def initialize(name, required, processor_for_values)
+          super(name, required, nil)
+          @processor_for_values = processor_for_values
+        end
+
+        def useful?
+          true
+        end
+
+        def validate_value(value)
+          if value
+            if value.is_a? Array
+              value.collect { |i| @processor_for_values.validate_value(i) }
+            else
+              raise SwaggerInvalidException.new("Value [#{name}] should be an array but is [#{value}]")
+            end
+          else
+            nil
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/sinatra/swagger-exposer/processing/{swagger-base-value-preprocessor.rb → swagger-base-value-processor.rb}

@@ -7,8 +7,8 @@ module Sinatra
 
     module Processing
 
-      # Base class for value preprocessor
-      class SwaggerBaseValuePreprocessor
+      # Base class for value processor
+      class SwaggerBaseValueProcessor
 
         attr_reader :name, :required
 
@@ -18,24 +18,26 @@ module Sinatra
         # @param name [String] the name
         # @param required [TrueClass] if the parameter is required
         # @param default [Object] the default value
-        def initialize(name, required, default = nil)
+        def initialize(name, required, default)
           @name = name.to_s
           @required = required
           @default = default
         end
 
+        # Test if the processor is useful
+        # @return [TrueClass]
         def useful?
           @required || (!@default.nil?)
         end
 
         def process(params)
           unless params.is_a? Hash
-            raise SwaggerInvalidException.new("Parameter [#{@name}] should be an object but is a [#{params.class}]")
+            raise SwaggerInvalidException.new("Value [#{@name}] should be an object but is a [#{params.class}]")
           end
-          if params.key?(@name)
-            params[@name] = validate_param_value(params[@name])
+          if params.key?(@name) && (!params[@name].nil?)
+            params[@name] = validate_value(params[@name])
           elsif @required
-            raise SwaggerInvalidException.new("Mandatory parameter [#{@name}] is missing")
+            raise SwaggerInvalidException.new("Mandatory value [#{@name}] is missing")
           elsif @default
             params[@name] = @default
           end

data/lib/sinatra/swagger-exposer/processing/{swagger-parameter-preprocessor.rb → swagger-parameter-processor.rb}

@@ -9,20 +9,20 @@ module Sinatra
     module Processing
 
       # Process the parameters for validation and enrichment
-      class SwaggerParameterPreprocessor
+      class SwaggerParameterProcessor
 
         include Sinatra::SwaggerExposer::SwaggerParameterHelper
 
         # Initialize
         # @param how_to_pass [String] how to pass the parameter
-        # @param value_preprocessor [Sinatra::SwaggerExposer::Processing::SwaggerBaseValuePreprocessor] the parameter processor
-        def initialize(how_to_pass, value_preprocessor)
+        # @param value_processor [Sinatra::SwaggerExposer::Processing::SwaggerBaseValueProcessor] the parameter processor
+        def initialize(how_to_pass, value_processor)
           @how_to_pass = how_to_pass
-          @value_preprocessor = value_preprocessor
-          @useful = @value_preprocessor.useful?
+          @value_processor = value_processor
+          @useful = @value_processor.useful?
         end
 
-        # Is the preprocessor useful
+        # Is the processor useful
         # @return [TrueClass]
         def useful?
           @useful
@@ -33,11 +33,11 @@ module Sinatra
             when HOW_TO_PASS_PATH
               # can't validate
             when HOW_TO_PASS_QUERY
-              @value_preprocessor.validate(app.params)
+              @value_processor.validate(app.params)
             when HOW_TO_PASS_HEADER
-              @value_preprocessor.validate(app.headers)
+              @value_processor.validate(app.headers)
             when HOW_TO_PASS_BODY
-              @value_preprocessor.validate(parsed_body || {})
+              @value_processor.validate(parsed_body || {})
           end
         end
 

data/lib/sinatra/swagger-exposer/processing/{swagger-primitive-value-preprocessor.rb → swagger-primitive-value-processor.rb}

@@ -1,6 +1,6 @@
 require 'date'
 
-require_relative 'swagger-base-value-preprocessor'
+require_relative 'swagger-base-value-processor'
 require_relative '../swagger-parameter-helper'
 require_relative '../swagger-invalid-exception'
 
@@ -10,8 +10,8 @@ module Sinatra
 
     module Processing
 
-      # Validate primitive parameters
-      class SwaggerPrimitiveValuePreprocessor < SwaggerBaseValuePreprocessor
+      # Validate primitive value
+      class SwaggerPrimitiveValueProcessor < SwaggerBaseValueProcessor
 
         include Sinatra::SwaggerExposer::SwaggerParameterHelper
 
@@ -31,67 +31,67 @@ module Sinatra
 
         def useful?
           super ||
-              [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
+            [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
 
         # Dispatch method
-        def validate_param_value(value)
+        def validate_value(value)
           case @type
             when TYPE_NUMBER
-              return validate_param_value_number(value)
+              return validate_value_number(value)
             when TYPE_INTEGER
-              return validate_param_value_integer(value)
+              return validate_value_integer(value)
             when TYPE_BOOLEAN
-              return validate_param_value_boolean(value)
+              return validate_value_boolean(value)
             when TYPE_DATE_TIME
-              return validate_param_value_date_time(value)
+              return validate_value_date_time(value)
             else
-              return validate_param_value_string(value)
+              return validate_value_string(value)
           end
         end
 
-        # Validate a boolean parameter
-        def validate_param_value_boolean(value)
+        # Validate a boolean
+        def validate_value_boolean(value)
           if (value == 'true') || value.is_a?(TrueClass)
-            return true
+            true
           elsif (value == 'false') || value.is_a?(FalseClass)
-            return false
+            false
           else
-            raise SwaggerInvalidException.new("Parameter [#{name}] should be an boolean but is [#{value}]")
+            raise SwaggerInvalidException.new("Value [#{name}] should be an boolean but is [#{value}]")
           end
         end
 
-        # Validate an integer parameter
-        def validate_param_value_integer(value)
+        # Validate an integer
+        def validate_value_integer(value)
           begin
             f = Float(value)
             i = Integer(value)
             if f == i
               i
             else
-              raise SwaggerInvalidException.new("Parameter [#{name}] should be an integer but is [#{value}]")
+              raise SwaggerInvalidException.new("Value [#{name}] should be an integer but is [#{value}]")
             end
             value = Integer(value)
             validate_numerical_value(value)
             value
           rescue ArgumentError
-            raise SwaggerInvalidException.new("Parameter [#{name}] should be an integer but is [#{value}]")
+            raise SwaggerInvalidException.new("Value [#{name}] should be an integer but is [#{value}]")
           rescue TypeError
-            raise SwaggerInvalidException.new("Parameter [#{name}] should be an integer but is [#{value}]")
+            raise SwaggerInvalidException.new("Value [#{name}] should be an integer but is [#{value}]")
           end
         end
 
-        # Validate a number parameter
-        def validate_param_value_number(value)
+        # Validate a number value
+        def validate_value_number(value)
           begin
             value = Float(value)
             validate_numerical_value(value)
             return value
           rescue ArgumentError
-            raise SwaggerInvalidException.new("Parameter [#{name}] should be a float but is [#{value}]")
+            raise SwaggerInvalidException.new("Value [#{name}] should be a float but is [#{value}]")
           rescue TypeError
-            raise SwaggerInvalidException.new("Parameter [#{name}] should be a float but is [#{value}]")
+            raise SwaggerInvalidException.new("Value [#{name}] should be a float but is [#{value}]")
           end
         end
 
@@ -99,46 +99,46 @@ module Sinatra
         # @param value [Numeric] the value
         def validate_numerical_value(value)
           validate_numerical_value_internal(
-              value,
-              PARAMS_MINIMUM,
-              PARAMS_EXCLUSIVE_MINIMUM,
-              '>=',
-              '>')
+            value,
+            PARAMS_MINIMUM,
+            PARAMS_EXCLUSIVE_MINIMUM,
+            '>=',
+            '>')
           validate_numerical_value_internal(
-              value,
-              PARAMS_MAXIMUM,
-              PARAMS_EXCLUSIVE_MAXIMUM,
-              '<=',
-              '<')
+            value,
+            PARAMS_MAXIMUM,
+            PARAMS_EXCLUSIVE_MAXIMUM,
+            '<=',
+            '<')
         end
 
-        # Validate a date time parameter
-        def validate_param_value_date_time(value)
+        # Validate a date time
+        def validate_value_date_time(value)
           begin
             DateTime.rfc3339(value)
           rescue ArgumentError
-            raise SwaggerInvalidException.new("Parameter [#{name}] should be a date time but is [#{value}]")
+            raise SwaggerInvalidException.new("Value [#{name}] should be a date time but is [#{value}]")
           end
         end
 
-        # Validate a string parameter
-        def validate_param_value_string(value)
+        # Validate a string
+        def validate_value_string(value)
           if value
-            validate_param_value_string_length(value, PARAMS_MIN_LENGTH, '>=')
-            validate_param_value_string_length(value, PARAMS_MAX_LENGTH, '<=')
+            validate_value_string_length(value, PARAMS_MIN_LENGTH, '>=')
+            validate_value_string_length(value, PARAMS_MAX_LENGTH, '<=')
           end
           value
         end
 
-        # Validate the length of a string parameter
+        # Validate the length of a string
         # @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)
+        def validate_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}]")
+              raise SwaggerInvalidException.new("Value [#{name}] length should be #{limit_param_method} than #{target_value} but is #{value.length} for [#{value}]")
             end
           end
         end
@@ -154,7 +154,7 @@ module Sinatra
             target_value = @params[limit_param_name]
             method_to_call = @params[exclusive_limit_param_name] ? exclusive_limit_param_method : limit_param_method
             unless value.send(method_to_call, target_value)
-              raise SwaggerInvalidException.new("Parameter [#{name}] should be #{method_to_call} than [#{target_value}] but is [#{value}]")
+              raise SwaggerInvalidException.new("Value [#{name}] should be #{method_to_call} than [#{target_value}] but is [#{value}]")
             end
           end
         end