sinatra-swagger-exposer 0.2.0 → 0.3.0

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

@@ -0,0 +1,82 @@
+require_relative '../swagger-invalid-exception'
+require_relative '../swagger-utilities'
+require_relative 'swagger-parameter-validation-helper'
+
+module Sinatra
+
+  module SwaggerExposer
+
+    module Configuration
+      # A property of a type
+      class SwaggerTypeProperty
+
+        attr_reader :name, :type, :items
+
+        include Sinatra::SwaggerExposer::SwaggerUtilities
+        include SwaggerParameterValidationHelper
+
+        OTHER_PROPERTIES = [:example, :description, :format, :minLength, :maxLength, :default]
+        PROPERTIES = [:type] + OTHER_PROPERTIES
+
+        def initialize(type_name, property_name, property_properties, known_types)
+          @name = property_name
+
+          unless property_properties.is_a? Hash
+            raise SwaggerInvalidException.new("Property [#{property_name}] value [#{property_properties}] of [#{type_name}] should be a hash")
+          end
+
+          if property_properties.key? :type
+            get_type(property_properties[:type], PRIMITIVE_TYPES + known_types)
+          end
+
+          white_list_params(property_properties, PROPERTIES)
+
+          validate_params(@type, property_properties)
+
+          @other_properties = property_properties.select do |key, value|
+            OTHER_PROPERTIES.include? key
+          end
+        end
+
+        def properties
+          @other_properties
+        end
+
+        def to_swagger
+          result = @other_properties.clone
+
+          if @type
+            if @type == TYPE_ARRAY
+              result[:type] = TYPE_ARRAY
+              if @items
+                if PRIMITIVE_TYPES.include? @items
+                  result[:items] = {:type => @items}
+                else
+                  result[:items] = ref_to_type(@items)
+                end
+              end
+            else
+              if PRIMITIVE_TYPES.include? @type
+                result[:type] = @type
+              else
+                result['$ref'] = "#/definitions/#{@type}"
+              end
+            end
+          end
+
+          result
+        end
+
+        def to_s
+          {
+              :name => @name,
+              :type => @type,
+              :items => @items,
+              :other_properties => @other_properties,
+          }.to_json
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,127 @@
+require_relative '../swagger-invalid-exception'
+require_relative '../swagger-utilities'
+require_relative 'swagger-type-property'
+
+module Sinatra
+
+  module SwaggerExposer
+
+    module Configuration
+      # A type
+      class SwaggerType
+
+        attr_reader :properties, :required, :extends
+
+        include Sinatra::SwaggerExposer::SwaggerUtilities
+
+        PROPERTY_PROPERTIES = :properties
+        PROPERTY_REQUIRED = :required
+        PROPERTY_EXAMPLE = :example
+        PROPERTY_EXTENDS = :extends
+        PROPERTIES = [PROPERTY_PROPERTIES, PROPERTY_REQUIRED, PROPERTY_EXAMPLE, PROPERTY_EXTENDS]
+
+        def initialize(type_name, type_properties, known_types)
+          white_list_params(type_properties, PROPERTIES)
+          @properties = process_properties(type_name, type_properties, known_types)
+          @required = process_required(type_name, type_properties, @properties.keys)
+          @example = process_example(type_name, type_properties, @properties.keys)
+          @extends = process_extends(type_properties, known_types)
+        end
+
+        def process_properties(type_name, type_content, known_types)
+          possible_value = check_attribute_empty_or_bad(type_name, type_content, PROPERTY_PROPERTIES, Hash)
+          if possible_value
+            possible_value
+          else
+            result = {}
+            type_content[PROPERTY_PROPERTIES].each_pair do |property_name, property_properties|
+              result[property_name.to_s] = SwaggerTypeProperty.new(type_name, property_name, property_properties, known_types)
+            end
+            result
+          end
+        end
+
+        def process_required(type_name, type_content, properties_names)
+          possible_value = check_attribute_empty_or_bad(type_name, type_content, PROPERTY_REQUIRED, Array)
+          if possible_value
+            possible_value
+          else
+            type_content[PROPERTY_REQUIRED].each do |property_name|
+              property_name = property_name.to_s
+              unless properties_names.include? property_name
+                raise SwaggerInvalidException.new("Required property [#{property_name}] of [#{type_name}] is unknown#{list_or_none(properties_names, 'properties')}")
+              end
+            end
+            type_content[PROPERTY_REQUIRED]
+          end
+        end
+
+        def process_example(type_name, type_content, properties_names)
+          possible_value = check_attribute_empty_or_bad(type_name, type_content, PROPERTY_EXAMPLE, Hash)
+          if possible_value
+            possible_value
+          else
+            type_content[PROPERTY_EXAMPLE].each_pair do |property_name, property_value|
+              property_name = property_name.to_s
+              unless properties_names.include? property_name
+                raise SwaggerInvalidException.new("Example property [#{property_name}] with value [#{property_value}] of [#{type_name}] is unknown#{list_or_none(properties_names, 'properties')}")
+              end
+            end
+            type_content[PROPERTY_EXAMPLE]
+          end
+        end
+
+        def check_attribute_empty_or_bad(type_name, type_content, attribute_name, attribute_class)
+          if !type_content.key?(attribute_name)
+            attribute_class.new
+          elsif !type_content[attribute_name].is_a? attribute_class
+            raise SwaggerInvalidException.new("Attribute [#{attribute_name}] of #{type_name} is not an hash: #{type_content[attribute_name]}")
+          end
+        end
+
+        def process_extends(type_properties, known_types)
+          if type_properties.key? PROPERTY_EXTENDS
+            check_type(type_properties[PROPERTY_EXTENDS], known_types)
+            @extends = type_properties[PROPERTY_EXTENDS]
+          end
+        end
+
+        def to_swagger
+          result = {:type => 'object'}
+
+          unless @properties.empty?
+            result[PROPERTY_PROPERTIES] = hash_to_swagger(@properties)
+          end
+
+          unless @required.empty?
+            result[PROPERTY_REQUIRED] = @required
+          end
+
+          unless @example.empty?
+            result[PROPERTY_EXAMPLE] = @example
+          end
+
+          if @extends
+            result = {
+                :allOf => [
+                    ref_to_type(@extends),
+                    result
+                ]
+            }
+          end
+
+          result
+        end
+
+        def to_s
+          {
+              :properties => @properties,
+              :required => @required,
+              :example => @example,
+          }.to_json
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,51 @@
+require_relative 'swagger-type'
+require_relative '../swagger-utilities'
+require_relative '../swagger-invalid-exception'
+
+module Sinatra
+
+  module SwaggerExposer
+
+    module Configuration
+
+      # Contain all the declared types
+      class SwaggerTypes
+
+        attr_reader :types
+
+        include Sinatra::SwaggerExposer::SwaggerUtilities
+
+        def initialize
+          @types = {}
+        end
+
+        def [](name)
+          @types[name]
+        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
+          @types[name] = SwaggerType.new(name, params, @types.keys)
+        end
+
+        def types_names
+          @types.keys
+        end
+
+        def to_swagger
+          if @types.empty?
+            nil
+          else
+            hash_to_swagger(@types)
+          end
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+require_relative '../swagger-parameter-helper'
+require_relative '../swagger-invalid-exception'
+require_relative 'swagger-base-value-preprocessor'
+
+module Sinatra
+
+  module SwaggerExposer
+
+    module Processing
+
+      # Validate arrays parameters
+      class SwaggerArrayValuePreprocessor < SwaggerBaseValuePreprocessor
+
+        include Sinatra::SwaggerExposer::SwaggerParameterHelper
+
+        attr_reader :preprocessor_for_values
+
+        # Initialize
+        # @param name [String] the name
+        # @param required [TrueClass] if the parameter is required
+        # @param preprocessor_for_values [Sinatra::SwaggerExposer::Processing::SwaggerBaseValuePreprocessor] processor for the values
+        def initialize(name, required, preprocessor_for_values)
+          super(name, required)
+          @preprocessor_for_values = preprocessor_for_values
+        end
+
+        def useful?
+          true
+        end
+
+        def validate_param_value(value)
+          if value
+            if value.is_a? Array
+              value.collect { |i| @preprocessor_for_values.validate_param_value(i) }
+            else
+              raise SwaggerInvalidException.new("Parameter [#{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

@@ -0,0 +1,48 @@
+require_relative '../swagger-parameter-helper'
+require_relative '../swagger-invalid-exception'
+
+module Sinatra
+
+  module SwaggerExposer
+
+    module Processing
+
+      # Base class for value preprocessor
+      class SwaggerBaseValuePreprocessor
+
+        attr_reader :name, :required
+
+        include Sinatra::SwaggerExposer::SwaggerParameterHelper
+
+        # Initialize
+        # @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)
+          @name = name.to_s
+          @required = required
+          @default = default
+        end
+
+        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}]")
+          end
+          if params.key?(@name)
+            params[@name] = validate_param_value(params[@name])
+          elsif @required
+            raise SwaggerInvalidException.new("Mandatory parameter [#{@name}] is missing")
+          elsif @default
+            params[@name] = @default
+          end
+          params
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,47 @@
+require_relative '../swagger-parameter-helper'
+require_relative '../swagger-invalid-exception'
+require_relative '../configuration/swagger-endpoint-parameter'
+
+module Sinatra
+
+  module SwaggerExposer
+
+    module Processing
+
+      # Process the parameters for validation and enrichment
+      class SwaggerParameterPreprocessor
+
+        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)
+          @how_to_pass = how_to_pass
+          @value_preprocessor = value_preprocessor
+          @useful = @value_preprocessor.useful?
+        end
+
+        # Is the preprocessor useful
+        # @return [TrueClass]
+        def useful?
+          @useful
+        end
+
+        def run(app, parsed_body)
+          case @how_to_pass
+            when HOW_TO_PASS_PATH
+              # can't validate
+            when HOW_TO_PASS_QUERY
+              @value_preprocessor.validate(app.params)
+            when HOW_TO_PASS_HEADER
+              @value_preprocessor.validate(app.headers)
+            when HOW_TO_PASS_BODY
+              @value_preprocessor.validate(parsed_body || {})
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/sinatra/swagger-exposer/processing/swagger-preprocessor-dispatcher.rb

@@ -0,0 +1,45 @@
+require_relative '../swagger-parameter-helper'
+
+module Sinatra
+
+  module SwaggerExposer
+
+    module Processing
+
+      # Dispatch content to a preprocessor
+      class SwaggerPreprocessorDispatcher
+
+        attr_reader :how_to_pass, :preprocessor
+
+        include Sinatra::SwaggerExposer::SwaggerParameterHelper
+
+        # Initialize
+        # @param how_to_pass how the value should be passed to the preprocessor
+        # @param preprocessor [Sinatra::SwaggerExposer::Processing::SwaggerBaseValuePreprocessor] processor for the values
+        def initialize(how_to_pass, preprocessor)
+          @how_to_pass = how_to_pass
+          @preprocessor = preprocessor
+        end
+
+        def useful?
+          (@how_to_pass != HOW_TO_PASS_PATH) && @preprocessor.useful?
+        end
+
+        # Process the value
+        def process(app, parsed_body)
+          case @how_to_pass
+            when HOW_TO_PASS_PATH
+              # can't validate
+            when HOW_TO_PASS_QUERY
+              @preprocessor.process(app.params)
+            when HOW_TO_PASS_HEADER
+              @preprocessor.process(app.headers)
+            when HOW_TO_PASS_BODY
+              @preprocessor.process(parsed_body || {})
+          end
+        end
+
+      end
+    end
+  end
+end