committee 2.5.1 → 3.0.0.alpha

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA256:
-  metadata.gz: 0b9f998d8056dd74bde5f8c3f522dc156d37af573a96ed089abe3d8a9e99c5d5
-  data.tar.gz: 70c8fb47979080bddcb70f7d736a82d7739cdbe89945303bb06767c8dcce6949
+SHA1:
+  metadata.gz: 2643d1595d38c9d9197a11c43ca05bb9a2da9c09
+  data.tar.gz: ebb69b45502334c6ad97d9d64a05d8f6855c5748
 SHA512:
-  metadata.gz: 4aa59b2147ab36885982da4da3e7b0cc20e70e4d9b6bd7b687a10cdbd1e1192a7ba58e0d160fc9ca11d5da646f1e0469a28859505fb48c37497da30f6d9cfb82
-  data.tar.gz: 6111d776b668b12b702c910655c901e5743e10adc3d4873b0f26b030b67b1d7a602cc2e141f037ea0729f5f73ac7e7a120794d715616330987afffa0693b7812
+  metadata.gz: f22b717d735d46455064a996423961f27c5115c15634f053397649d114c6759b229b5ce2eea09086c9f7733f270cfc342faf3bf1f77d6740130cb66b39e5f22e
+  data.tar.gz: c1bc25f4841bfb2e10567e9b20a18f51daadb7f8c2c55068c8954f31692f8b90e02fac5beec1ed91c813e8db77e4e44a8bd7afbbc73b902d243990f6b54cae18

data/lib/committee.rb

@@ -1,26 +1,37 @@
 require "json"
 require "json_schema"
 require "rack"
+require 'openapi_parser'
 
 require_relative "committee/errors"
-require_relative "committee/string_params_coercer"
 require_relative "committee/parameter_coercer"
 require_relative "committee/request_unpacker"
-require_relative "committee/request_validator"
-require_relative "committee/response_generator"
-require_relative "committee/response_validator"
-require_relative "committee/router"
+
 require_relative "committee/validation_error"
 
 require_relative "committee/drivers"
 require_relative "committee/drivers/hyper_schema"
 require_relative "committee/drivers/open_api_2"
+require_relative "committee/drivers/open_api_3"
 
 require_relative "committee/middleware/base"
 require_relative "committee/middleware/request_validation"
 require_relative "committee/middleware/response_validation"
 require_relative "committee/middleware/stub"
 
+require_relative "committee/schema_validator/option"
+require_relative "committee/schema_validator/open_api_3"
+require_relative "committee/schema_validator/open_api_3/router"
+require_relative "committee/schema_validator/open_api_3/operation_wrapper"
+require_relative "committee/schema_validator/open_api_3/request_validator"
+require_relative "committee/schema_validator/open_api_3/response_validator"
+require_relative "committee/schema_validator/hyper_schema"
+require_relative "committee/schema_validator/hyper_schema/request_validator"
+require_relative "committee/schema_validator/hyper_schema/response_generator"
+require_relative "committee/schema_validator/hyper_schema/response_validator"
+require_relative "committee/schema_validator/hyper_schema/router"
+require_relative "committee/schema_validator/hyper_schema/string_params_coercer"
+
 require_relative "committee/bin/committee_stub"
 
 require_relative "committee/test/methods"

data/lib/committee/bin/committee_stub.rb

@@ -1,3 +1,5 @@
+# Don't Support OpenAPI3
+
 module Committee
   module Bin
     # CommitteeStub internalizes the functionality of bin/committee-stub so
@@ -8,6 +10,8 @@ module Committee
       def get_app(schema, options)
         cache = {}
 
+        raise Committee::NotSupportOpenAPI3.new("OpenAPI3 not support stub") unless schema.support_stub?
+
         Rack::Builder.new {
           unless options[:tolerant]
             use Committee::Middleware::RequestValidation, schema: schema

data/lib/committee/drivers.rb

@@ -8,39 +8,13 @@ module Committee
         Committee::Drivers::HyperSchema.new
       when :open_api_2
         Committee::Drivers::OpenAPI2.new
+      when :open_api_3
+        Committee::Drivers::OpenAPI3.new
       else
         raise ArgumentError, %{Committee: unknown driver "#{name}".}
       end
     end
 
-    # load and build drive from JSON file
-    # @param [String] schema_path
-    # @return [Committee::Driver]
-    def self.load_from_json(schema_path)
-      json = JSON.parse(File.read(schema_path))
-      load_from_data(json)
-    end
-
-    # load and build drive from Hash object
-    # @param [Hash] hash
-    # @return [Committee::Driver]
-    def self.load_from_data(hash)
-      driver = if hash['swagger'] == '2.0'
-                 Committee::Drivers::OpenAPI2.new
-               else
-                 Committee::Drivers::HyperSchema.new
-               end
-
-      driver.parse(hash)
-    end
-
-    # load and build drive from file
-    # @param [String] schema_path
-    # @return [Committee::Driver]
-    def self.load_from_file(schema_path)
-      load_from_json(schema_path)
-    end
-
     # Driver is a base class for driver implementations.
     class Driver
       # Whether parameters that were form-encoded will be coerced by default.
@@ -85,6 +59,15 @@ module Committee
       def driver
         raise "needs implementation"
       end
+
+      def build_router(options)
+        raise "needs implementation"
+      end
+
+      # OpenAPI3 not support stub but JSON Hyper-Schema and OpenAPI2 support
+      def support_stub?
+        true
+      end
     end
   end
-end
+end

data/lib/committee/drivers/hyper_schema.rb

@@ -17,6 +17,10 @@ module Committee::Drivers
       false
     end
 
+    def default_coerce_date_times
+      false
+    end
+
     def name
       :hyper_schema
     end
@@ -114,6 +118,11 @@ module Committee::Drivers
       attr_accessor :driver
 
       attr_accessor :routes
+
+      def build_router(options)
+        validator_option = Committee::SchemaValidator::Option.new(options, self, :hyper_schema)
+        Committee::SchemaValidator::HyperSchema::Router.new(self, validator_option)
+      end
     end
 
     private

data/lib/committee/drivers/open_api_2.rb

@@ -17,6 +17,10 @@ module Committee::Drivers
       true
     end
 
+    def default_coerce_date_times
+      false
+    end
+
     def name
       :open_api_2
     end
@@ -173,26 +177,6 @@ module Committee::Drivers
               # therefore this should map over quite well.
               param_schema.type = [param_data["type"]]
 
-              param_schema.enum = param_data["enum"] unless param_data["enum"].nil?
-
-              # validation: string
-              param_schema.format = param_data["format"] unless param_data["format"].nil?
-              param_schema.pattern = Regexp.new(param_data["pattern"]) unless param_data["pattern"].nil?
-              param_schema.min_length = param_data["minLength"] unless param_data["minLength"].nil?
-              param_schema.max_length = param_data["maxLength"] unless param_data["maxLength"].nil?
-
-              # validation: array
-              param_schema.min_items = param_data["minItems"] unless param_data["minItems"].nil?
-              param_schema.max_items = param_data["maxItems"] unless param_data["maxItems"].nil?
-              param_schema.unique_items = param_data["uniqueItems"] unless param_data["uniqueItems"].nil?
-
-              # validation: number/integer
-              param_schema.min = param_data["minimum"] unless param_data["minimum"].nil?
-              param_schema.min_exclusive = param_data["exclusiveMinimum"] unless param_data["exclusiveMinimum"].nil?
-              param_schema.max = param_data["maximum"] unless param_data["maximum"].nil?
-              param_schema.max_exclusive = param_data["exclusiveMaximum"] unless param_data["exclusiveMaximum"].nil?
-              param_schema.multiple_of = param_data["multipleOf"] unless param_data["multipleOf"].nil?
-
               # And same idea: despite parameters not being schemas, the items
               # key (if preset) is actually a schema that defines each item of an
               # array type, so we can just reflect that directly onto our
@@ -224,6 +208,11 @@ module Committee::Drivers
       attr_accessor :definitions
       attr_accessor :produces
       attr_accessor :routes
+
+      def build_router(options)
+        validator_option = Committee::SchemaValidator::Option.new(options, self, :hyper_schema)
+        Committee::SchemaValidator::HyperSchema::Router.new(self, validator_option)
+      end
     end
 
     private

data/lib/committee/drivers/open_api_3.rb

@@ -0,0 +1,70 @@
+module Committee::Drivers
+  class OpenAPI3 < Committee::Drivers::Driver
+    # Whether parameters that were form-encoded will be coerced by default.
+    def default_coerce_form_params
+      true
+    end
+
+    # Whether parameters in a request's path will be considered and coerced by
+    # default.
+    def default_path_params
+      true
+    end
+
+    # Whether parameters in a request's query string will be considered and
+    # coerced by default.
+    def default_query_params
+      true
+    end
+
+    def default_coerce_date_times
+      true
+    end
+
+    def name
+      :open_api_3
+    end
+
+    # TODO: check it's need?
+    def schema_class
+      Committee::Drivers::OpenAPI3::Schema
+    end
+
+    def parse(open_api)
+      Schema.new(self, open_api)
+    end
+
+    class Schema < Committee::Drivers::Schema
+      attr_reader :open_api
+
+      # @!attribute [r] open_api
+      #   @return [OpenAPIParser::Schemas::OpenAPI]
+
+      def initialize(driver, open_api)
+        @open_api = open_api
+        @driver = driver
+      end
+
+      def support_stub?
+        false
+      end
+
+      def driver # we don't use attr_reader because this method override super class
+        @driver
+      end
+
+      def build_router(options)
+        validator_option = Committee::SchemaValidator::Option.new(options, self, :open_api_3)
+        Committee::SchemaValidator::OpenAPI3::Router.new(self, validator_option)
+      end
+
+      # OpenAPI3 only
+      def operation_object(path, method)
+        request_operation = open_api.request_operation(method, path)
+        return nil unless request_operation
+
+        Committee::SchemaValidator::OpenAPI3::OperationWrapper.new(request_operation)
+      end
+    end
+  end
+end

data/lib/committee/errors.rb

@@ -16,4 +16,7 @@ module Committee
 
   class ReferenceNotFound < Error
   end
+
+  class NotSupportOpenAPI3 < Error
+  end
 end

data/lib/committee/middleware/base.rb

@@ -4,14 +4,11 @@ module Committee::Middleware
       @app = app
 
       @error_class = options.fetch(:error_class, Committee::ValidationError)
-      @params_key = options[:params_key] || "committee.params"
-      @headers_key = options[:headers_key] || "committee.headers"
+
       @raise = options[:raise]
-      @schema = get_schema(options)
+      @schema = self.class.get_schema(options)
 
-      @router = Committee::Router.new(@schema,
-        prefix: options[:prefix]
-      )
+      @router = @schema.build_router(options)
     end
 
     def call(env)
@@ -24,70 +21,31 @@ module Committee::Middleware
       end
     end
 
-    private
-
-    # For modern use of the library a schema should be an instance of
-    # Committee::Drivers::Schema so that we know that all the computationally
-    # difficult parsing is already done by the time we try to handle any
-    # request.
-    #
-    # However, for reasons of backwards compatibility we also allow schema
-    # input to be a string, a data hash, or a JsonSchema::Schema. In the former
-    # two cases we just parse as if we were sent hyper-schema. In the latter,
-    # we have the hyper-schema driver wrap it in a new Committee object.
-    def get_schema(options)
-      schema = options[:schema]
-      unless schema
-        schema = Committee::Drivers::load_from_file(options[:schema_path]) if options[:schema_path]
-
-        raise(ArgumentError, "Committee: need option `schema` or schema_path") unless schema
-      end
-
-      # These are in a separately conditional ladder so that we only show the
-      # user one warning.
-      if schema.is_a?(String)
-        warn_string_deprecated
-      elsif schema.is_a?(Hash)
-        warn_hash_deprecated
-      elsif schema.is_a?(JsonSchema::Schema)
-        warn_json_schema_deprecated
-      end
+    class << self
+      def get_schema(options)
+        open_api_3 = options[:open_api_3]
+        return open_api_3 if open_api_3
 
-      if schema.is_a?(String)
-        schema = JSON.parse(schema)
-      end
+        schema = options[:schema]
 
-      if schema.is_a?(Hash) || schema.is_a?(JsonSchema::Schema)
-        driver = Committee::Drivers::HyperSchema.new
+        if schema
+          # Expect the type we want by now. If we don't have it, the user passed
+          # something else non-standard in.
+          if !schema.is_a?(Committee::Drivers::Schema)
+            raise ArgumentError, "Committee: schema expected to be an instance of Committee::Drivers::Schema."
+          end
 
-        # The driver itself has its own special cases to be able to parse
-        # either a hash or JsonSchema::Schema object.
-        schema = driver.parse(schema)
-      end
+          return schema
+        end
 
-      # Expect the type we want by now. If we don't have it, the user passed
-      # something else non-standard in.
-      if !schema.is_a?(Committee::Drivers::Schema)
-        raise ArgumentError, "Committee: schema expected to be an instance of " \
-          "Committee::Drivers::Schema."
+        raise(ArgumentError, "Committee: need option `schema` or `open_api_3`")
       end
-
-      schema
     end
 
-    def warn_json_schema_deprecated
-      Committee.warn_deprecated("Committee: passing a JsonSchema::Schema to schema " \
-        "option is deprecated; please send an instance of Committee::Drivers::Schema instead.")
-    end
-
-    def warn_hash_deprecated
-      Committee.warn_deprecated("Committee: passing a hash to schema " \
-        "option is deprecated; please send an instance of Committee::Drivers::Schema instead.")
-    end
+    private
 
-    def warn_string_deprecated
-      Committee.warn_deprecated("Committee: passing a string to schema " \
-        "option is deprecated; please send an instance of Committee::Drivers::Schema instead.")
+    def build_schema_validator(request)
+      @router.build_schema_validator(request)
     end
   end
 end

data/lib/committee/middleware/request_validation.rb

@@ -3,68 +3,19 @@ module Committee::Middleware
     def initialize(app, options={})
       super
 
-      @allow_form_params   = options.fetch(:allow_form_params, true)
-      @allow_query_params  = options.fetch(:allow_query_params, true)
-      @check_content_type  = options.fetch(:check_content_type, true)
-      @check_header        = options.fetch(:check_header, true)
-      @optimistic_json     = options.fetch(:optimistic_json, false)
-      @strict              = options[:strict]
-      @coerce_date_times   = options.fetch(:coerce_date_times, false)
-      @coerce_recursive = options.fetch(:coerce_recursive, true)
-
-      @coerce_form_params = options.fetch(:coerce_form_params,
-        @schema.driver.default_coerce_form_params)
-      @coerce_path_params = options.fetch(:coerce_path_params,
-        @schema.driver.default_path_params)
-      @coerce_query_params = options.fetch(:coerce_query_params,
-        @schema.driver.default_query_params)
+      @strict  = options[:strict]
 
       # deprecated
       @allow_extra = options[:allow_extra]
     end
 
     def handle(request)
-      link, param_matches = @router.find_request_link(request)
-
-      if link
-        # Attempts to coerce parameters that appear in a link's URL to Ruby
-        # types that can be validated with a schema.
-        if @coerce_path_params
-          Committee::StringParamsCoercer.new(param_matches, link.schema, coerce_recursive: @coerce_recursive).call!
-        end
-
-        # Attempts to coerce parameters that appear in a query string to Ruby
-        # types that can be validated with a schema.
-        if @coerce_query_params && !request.GET.nil? && !link.schema.nil?
-          Committee::StringParamsCoercer.new(request.GET, link.schema, coerce_recursive: @coerce_recursive).call!
-        end
-      end
-
-      request.env[@params_key], request.env[@headers_key] = Committee::RequestUnpacker.new(
-        request,
-        allow_form_params:  @allow_form_params,
-        allow_query_params: @allow_query_params,
-        coerce_form_params: @coerce_form_params,
-        optimistic_json:    @optimistic_json,
-        coerce_recursive:   @coerce_recursive,
-        schema:             link ? link.schema : nil
-      ).call
+      schema_validator = build_schema_validator(request)
+      schema_validator.request_validate(request)
 
-      request.env[@params_key].merge!(param_matches) if param_matches
+      raise Committee::NotFound, "That request method and path combination isn't defined." if !schema_validator.link_exist? && @strict
 
-      if link
-        validator = Committee::RequestValidator.new(link, check_content_type: @check_content_type, check_header: @check_header)
-        validator.call(request, request.env[@params_key], request.env[@headers_key])
-
-        parameter_coerce!(request, link, @params_key)
-        parameter_coerce!(request, link, "rack.request.query_hash") if !request.GET.nil? && !link.schema.nil?
-
-        @app.call(request.env)
-      elsif @strict
-        raise Committee::NotFound, "That request method and path combination isn't defined."
-      else
-        @app.call(request.env)
-      end
+      @app.call(request.env)
     rescue Committee::BadRequest, Committee::InvalidRequest
       raise if @raise
       @error_class.new(400, :bad_request, $!.message).render
@@ -79,13 +30,5 @@ module Committee::Middleware
       raise Committee::InvalidRequest if @raise
       @error_class.new(400, :bad_request, "Request body wasn't valid JSON.").render
     end
-
-    private
-
-      def parameter_coerce!(request, link, coerce_key)
-        Committee::ParameterCoercer.
-            new(request.env[coerce_key], link.schema, coerce_date_times: @coerce_date_times, coerce_recursive: @coerce_recursive).
-            call!
-      end
   end
 end