sinatra-swagger-exposer 0.3.0 → 0.4.0

data/lib/sinatra/swagger-exposer/processing/swagger-type-value-preprocessor.rb

@@ -1,37 +0,0 @@
-require_relative 'swagger-base-value-preprocessor'
-
-module Sinatra
-
-  module SwaggerExposer
-
-    module Processing
-
-      # A preprocessor for a type parameter
-      class SwaggerTypeValuePreprocessor < SwaggerBaseValuePreprocessor
-
-        attr_reader :attributes_preprocessors
-
-        # Initialize
-        # @param name [String] the name
-        # @param required [TrueClass] if the parameter is required
-        # @param attributes_preprocessors [Array[Sinatra::SwaggerExposer::Processing::SwaggerBaseValuePreprocessor]] the attributes preprocessors
-        def initialize(name, required, attributes_preprocessors)
-          super(name, required)
-          @attributes_preprocessors = attributes_preprocessors
-        end
-
-        def useful?
-          super || (!(@attributes_preprocessors.empty?))
-        end
-
-        def validate_param_value(value)
-          @attributes_preprocessors.each do |attribute_preprocessor|
-            attribute_preprocessor.process(value)
-          end
-          value
-        end
-
-      end
-    end
-  end
-end

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

@@ -1,137 +0,0 @@
-require_relative 'swagger-utilities'
-require_relative 'processing/swagger-array-value-preprocessor'
-require_relative 'processing/swagger-preprocessor-dispatcher'
-require_relative 'processing/swagger-primitive-value-preprocessor'
-require_relative 'processing/swagger-request-preprocessor'
-require_relative 'processing/swagger-type-value-preprocessor'
-
-module Sinatra
-
-  module SwaggerExposer
-
-    # Create processor from configuration
-    class SwaggerPreprocessorCreator
-
-      include Sinatra::SwaggerExposer::SwaggerUtilities
-
-      # Initialize
-      # @param types [Sinatra::SwaggerExposer::SwaggerTypes]
-      def initialize(types)
-        @types = types
-      end
-
-      # Create an endpoint processor
-      # @param swagger_endpoint [Sinatra::SwaggerExposer::Configuration::SwaggerEndpoint] the endpoint
-      # @return [Sinatra::SwaggerExposer::Processing::SwaggerRequestPreprocessor]
-      def create_endpoint_processor(swagger_endpoint)
-        request_preprocessor = Sinatra::SwaggerExposer::Processing::SwaggerRequestPreprocessor.new
-        swagger_endpoint.parameters.each do |parameter|
-          preprocessor = create_value_preprocessor(parameter)
-          dispatcher = Sinatra::SwaggerExposer::Processing::SwaggerPreprocessorDispatcher.new(parameter.how_to_pass, preprocessor)
-          if dispatcher.useful?
-            request_preprocessor.add_dispatcher(dispatcher)
-          end
-        end
-        request_preprocessor
-      end
-
-      private
-
-      # Create a parameter preprocessor for a parameter
-      # @param parameter [Sinatra::SwaggerExposer::Configuration::SwaggerEndpointParameter]
-      def create_value_preprocessor(parameter)
-        type_name = parameter.type
-        if type_name == TYPE_ARRAY
-          if PRIMITIVE_TYPES.include? parameter.items
-            preprocessor_for_values = Sinatra::SwaggerExposer::Processing::SwaggerPrimitiveValuePreprocessor.new(
-                parameter.name,
-                false,
-                parameter.items,
-                parameter.default,
-                parameter.params
-            )
-          else
-            preprocessor_for_values = create_preprocessor_for_type(parameter.name, parameter.items, false)
-          end
-          Sinatra::SwaggerExposer::Processing::SwaggerArrayValuePreprocessor.new(parameter.name, parameter.required, preprocessor_for_values)
-        elsif PRIMITIVE_TYPES.include? type_name
-          Sinatra::SwaggerExposer::Processing::SwaggerPrimitiveValuePreprocessor.new(
-              parameter.name,
-              parameter.required,
-              type_name,
-              parameter.default,
-              parameter.params
-          )
-        else
-          create_preprocessor_for_type(parameter.name, parameter.type, parameter.required)
-        end
-      end
-
-      # Create a type parameter preprocessor for a type parameter
-      # @param parameter_name [String] the parameter name
-      # @param parameter_type [String] the parameter type
-      # @param parameter_required [TrueClass] if the parameter is required
-      # @return [Sinatra::SwaggerExposer::Processing::SwaggerTypeValuePreprocessor]
-      def create_preprocessor_for_type(parameter_name, parameter_type, parameter_required)
-        attributes_preprocessors = create_attributes_preprocessors_for_type(parameter_type)
-        Sinatra::SwaggerExposer::Processing::SwaggerTypeValuePreprocessor.new(
-            parameter_name,
-            parameter_required,
-            attributes_preprocessors
-        )
-      end
-
-      # Get attributes preprocessor for a type
-      # @param type_name [String] the type name
-      # @return [Array[Sinatra::SwaggerExposer::Processing::SwaggerPrimitiveValuePreprocessor]]
-      def create_attributes_preprocessors_for_type(type_name)
-        type = @types[type_name]
-        attributes_preprocessors = []
-        type.properties.each_pair do |property_name, property|
-          attributes_preprocessors <<
-              create_preprocessor_for_property(
-                  property_name,
-                  property,
-                  type.required.include?(property.name)
-              )
-        end
-        if type.extends
-          attributes_preprocessors = attributes_preprocessors + create_attributes_preprocessors_for_type(type.extends)
-        end
-        attributes_preprocessors
-      end
-
-      # Create a processor for a type property
-      # @param type_property [Sinatra::SwaggerExposer::Configuration::SwaggerTypeProperty]
-      def create_preprocessor_for_property(name, type_property, required)
-        property_type = type_property.type
-        if property_type == TYPE_ARRAY
-          if PRIMITIVE_TYPES.include? type_property.items
-            preprocessor_for_values = Sinatra::SwaggerExposer::Processing::SwaggerPrimitiveValuePreprocessor.new(
-                name,
-                false,
-                type_property.items,
-                type_property.properties[:default],
-                type_property.properties
-            )
-          else
-            preprocessor_for_values = create_preprocessor_for_type(name, type_property.items, false)
-          end
-          Sinatra::SwaggerExposer::Processing::SwaggerArrayValuePreprocessor.new(name, required, preprocessor_for_values)
-        elsif PRIMITIVE_TYPES.include? property_type
-          Sinatra::SwaggerExposer::Processing::SwaggerPrimitiveValuePreprocessor.new(
-              name,
-              required,
-              property_type,
-              type_property.properties[:default],
-              type_property.properties
-          )
-        else
-          create_preprocessor_for_type(name, property_type, required)
-        end
-      end
-
-    end
-
-  end
-end

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

@@ -1,108 +0,0 @@
-require_relative 'swagger-invalid-exception'
-require_relative 'swagger-parameter-helper'
-
-module Sinatra
-
-  module SwaggerExposer
-
-    module SwaggerUtilities
-
-      include ::Sinatra::SwaggerExposer::SwaggerParameterHelper
-
-      def ref_to_type(type)
-        {'$ref' => "#/definitions/#{type}"}
-      end
-
-      def hash_to_swagger(hash)
-        result = {}
-        hash.each_pair do |key, value|
-          result[key] = value.to_swagger
-        end
-        result
-      end
-
-      # Transform a type into a String
-      # @return [String]
-      def type_to_s(value)
-        if [TrueClass, FalseClass].include? value
-          TYPE_BOOLEAN
-        elsif value == DateTime
-          TYPE_DATE_TIME
-        elsif value.is_a? Class
-          value.to_s.downcase
-        else
-          value
-        end
-      end
-
-      def get_type(type, possible_values)
-        @type = type
-        if type.nil?
-          raise SwaggerInvalidException.new('Type is nil')
-        elsif type.is_a?(String) || @type.is_a?(Class)
-          @type = type_to_s(@type)
-          check_type(@type, possible_values)
-        elsif @type.is_a? Array
-          @items = type_to_s(get_array_type(@type))
-          check_type(@items, possible_values)
-          @type = TYPE_ARRAY
-        else
-          raise SwaggerInvalidException.new("Type [#{@type}] of has an unknown type, should be a class, a string or an array")
-        end
-      end
-
-      # Validate if a parameter is in a list of available values
-      # @param params [Hash] the parameters
-      # @param allowed_values [Enumerable, #include?] the 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|
-          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)
-        if list.empty?
-          ", no available #{name}"
-        else
-          ", possible #{name} are #{list.join(', ')}"
-        end
-      end
-
-      private
-
-      def get_array_type(array)
-        if array.empty?
-          raise SwaggerInvalidException.new('Type is an empty array, you should specify a type as the array content')
-        elsif array.length > 1
-          raise SwaggerInvalidException.new("Type [#{array}] has more than one entry, it should only have one")
-        else
-          type_to_s(array[0])
-        end
-      end
-
-      # Validate if a type is in a list of available values
-      # @param type [String] the parameter
-      # @param allowed_values [Enumerable, #include?] the allowed values
-      # @return [NilClass]
-      def check_type(type, allowed_values)
-        if allowed_values.empty?
-          raise SwaggerInvalidException.new("Unknown type [#{type}], no available type")
-        elsif !allowed_values.include?(type)
-          raise SwaggerInvalidException.new("Unknown type [#{type}]#{list_or_none(allowed_values, 'types')}")
-        end
-      end
-
-    end
-
-  end
-
-end
-