committee 4.99.1 → 5.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d369a9be7988a151dbd3b7d9f0065cc821ffcdc8e2543b95355b22fb1f93f6b8
-  data.tar.gz: 356fa03d1f3405544d7251302f012f48c0587c31c09b60f2509bdf7776e0c95c
+  metadata.gz: 284c8c1198255435e959dcee2b92cb25c3d80dd5fe6d4622b8077a69525712ed
+  data.tar.gz: b306ec0ad5e628d9cc7b6382781c4b710c99bedb127a7000edadf9d0e0b8fa84
 SHA512:
-  metadata.gz: 6c821b9f35b1eb20ebea532e8cbc901295596136ccdd680c34ee6eed48da8858c2a22a754a52812cc66de43598f90515ec8642753cb4d3e46390dfd3f840b6a4
-  data.tar.gz: 6b720c3e1e2c25e7f8682ba4b8db3879d552a943ec7739d6686baa62b5c4985f609643ed43db67b135025d76e7bde7ff767629ae57b5da27b82107dc6a325629
+  metadata.gz: 687d9a47d2a17786313bde939339d464a8d775795458b09ad7d7784bfa337f848a9ffabe240e9f39173c4466589c026f64a8eede768e7abfff4b01b2672339f5
+  data.tar.gz: 4ee7781341de9ebafae28d01d98c0f72d54067c425f3ee10b221c4eb88da85e79b36853bbda4818b20348177f8d975103cc5be694ff7e8252a6634a856853b7c

data/lib/committee/drivers/hyper_schema/schema.rb

@@ -12,8 +12,8 @@ module Committee
 
         attr_reader :validator_option
 
-        def build_router(options, is_request)
-          @validator_option = Committee::SchemaValidator::Option.new(options, self, :hyper_schema, is_request)
+        def build_router(options)
+          @validator_option = Committee::SchemaValidator::Option.new(options, self, :hyper_schema)
           Committee::SchemaValidator::HyperSchema::Router.new(self, @validator_option)
         end
       end

data/lib/committee/drivers/open_api_2/driver.rb

@@ -59,7 +59,7 @@ module Committee
           schema.base_path = data['basePath'] || ''
 
           # Arbitrarily choose the first media type found in these arrays. This
-          # appraoch could probably stand to be improved, but at least users will
+          # approach could probably stand to be improved, but at least users will
           # for now have the option of turning media type validation off if they so
           # choose.
           schema.consumes = data['consumes'].first

data/lib/committee/drivers/open_api_2/parameter_schema_builder.rb

@@ -62,7 +62,7 @@ module Committee
                 # 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
-                # artifical schema.
+                # artificial schema.
                 if param_data["type"] == "array" && param_data["items"]
                   param_schema.items = param_data["items"]
                 end

data/lib/committee/drivers/open_api_2/schema.rb

@@ -16,8 +16,8 @@ module Committee
         attr_accessor :routes
         attr_reader :validator_option
 
-        def build_router(options, is_request)
-          @validator_option = Committee::SchemaValidator::Option.new(options, self, :hyper_schema, is_request)
+        def build_router(options)
+          @validator_option = Committee::SchemaValidator::Option.new(options, self, :hyper_schema)
           Committee::SchemaValidator::HyperSchema::Router.new(self, @validator_option)
         end
       end

data/lib/committee/drivers/open_api_3/schema.rb

@@ -23,8 +23,8 @@ module Committee
           @driver
         end
 
-        def build_router(options, is_request)
-          @validator_option = Committee::SchemaValidator::Option.new(options, self, :open_api_3, is_request)
+        def build_router(options)
+          @validator_option = Committee::SchemaValidator::Option.new(options, self, :open_api_3)
           Committee::SchemaValidator::OpenAPI3::Router.new(self, @validator_option)
         end
 

data/lib/committee/drivers/schema.rb

@@ -10,7 +10,7 @@ module Committee
         raise "needs implementation"
       end
 
-      def build_router(options, is_request)
+      def build_router(options)
         raise "needs implementation"
       end
 

data/lib/committee/drivers.rb

@@ -20,26 +20,27 @@ module Committee
     # load and build drive from JSON file
     # @param [String] schema_path
     # @return [Committee::Driver]
-    def self.load_from_json(schema_path)
-      load_from_data(JSON.parse(File.read(schema_path)), schema_path)
+    def self.load_from_json(schema_path, parser_options: {})
+      load_from_data(JSON.parse(File.read(schema_path)), schema_path, parser_options: parser_options)
     end
 
     # load and build drive from YAML file
     # @param [String] schema_path
     # @return [Committee::Driver]
-    def self.load_from_yaml(schema_path)
-      load_from_data(YAML.load_file(schema_path), schema_path)
+    def self.load_from_yaml(schema_path, parser_options: {})
+      data = YAML.respond_to?(:unsafe_load_file) ? YAML.unsafe_load_file(schema_path) : YAML.load_file(schema_path)
+      load_from_data(data, schema_path, parser_options: parser_options)
     end
 
     # load and build drive from file
     # @param [String] schema_path
     # @return [Committee::Driver]
-    def self.load_from_file(schema_path)
+    def self.load_from_file(schema_path, parser_options: {})
       case File.extname(schema_path)
       when '.json'
-        load_from_json(schema_path)
+        load_from_json(schema_path, parser_options: parser_options)
       when '.yaml', '.yml'
-        load_from_yaml(schema_path)
+        load_from_yaml(schema_path, parser_options: parser_options)
       else
         raise "Committee only supports the following file extensions: '.json', '.yaml', '.yml'"
       end
@@ -48,9 +49,19 @@ module Committee
     # load and build drive from Hash object
     # @param [Hash] hash
     # @return [Committee::Driver]
-    def self.load_from_data(hash, schema_path = nil)
+    def self.load_from_data(hash, schema_path = nil, parser_options: {})
       if hash['openapi']&.start_with?('3.0.')
-        openapi = OpenAPIParser.parse_with_filepath(hash, schema_path)
+        # From the next major version, we want to ensure `{ strict_reference_validation: true }`
+        # as a parser option here, but since it may break existing implementations, just warn
+        # if it is not explicitly set. See: https://github.com/interagent/committee/issues/343#issuecomment-997400329
+        opts = parser_options.dup
+
+        Committee.warn_deprecated_until_6(!opts.key?(:strict_reference_validation), 'openapi_parser will default to strict reference validation ' +
+        'from next version. Pass config `strict_reference_validation: true` (or false, if you must) ' +
+        'to quiet this warning.')
+        opts[:strict_reference_validation] ||= false
+        
+        openapi = OpenAPIParser.parse_with_filepath(hash, schema_path, opts)
         return Committee::Drivers::OpenAPI3::Driver.new.parse(openapi)
       end
 
@@ -60,6 +71,7 @@ module Committee
                  Committee::Drivers::HyperSchema::Driver.new
                end
 
+      # TODO: in the future, pass `opts` here and allow optionality in other drivers?
       driver.parse(hash)
     end
   end

data/lib/committee/middleware/base.rb

@@ -13,7 +13,7 @@ module Committee
         @raise = options[:raise]
         @schema = self.class.get_schema(options)
 
-        @router = @schema.build_router(options, is_request: Committee::Middleware::RequestValidation == self.class)
+        @router = @schema.build_router(options)
         @accept_request_filter = options[:accept_request_filter] || -> (_) { true }
       end
 
@@ -30,11 +30,12 @@ module Committee
       class << self
         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
+          if !schema && options[:schema_path]
+            # In the future, we could have `parser_options` as an exposed config?
+            parser_options = options.key?(:strict_reference_validation) ? { strict_reference_validation: options[:strict_reference_validation] } : {}
+            schema = Committee::Drivers::load_from_file(options[:schema_path], parser_options: parser_options)
           end
+          raise(ArgumentError, "Committee: need option `schema` or `schema_path`") unless schema
 
           # Expect the type we want by now. If we don't have it, the user passed
           # something else non-standard in.

data/lib/committee/middleware/request_validation.rb

@@ -34,14 +34,7 @@ module Committee
       private
 
       def handle_exception(e, env)
-        return unless @error_handler
-
-        if @error_handler.arity > 1
-          @error_handler.call(e, env)
-        else
-          Committee.warn_deprecated('Using `error_handler.call(exception)` is deprecated and will be change to `error_handler.call(exception, request.env)` in next major version.')
-          @error_handler.call(e)
-        end
+        @error_handler.call(e, env) if @error_handler
       end
     end
   end

data/lib/committee/middleware/response_validation.rb

@@ -7,10 +7,7 @@ module Committee
 
       def initialize(app, options = {})
         super
-
-        unless options[:strict].nil?
-          Committee.warn_deprecated("Committee: Committee::Middleware::ResponseValidation doesn't support strict option now but we'll support this option. This change break backward compatibility so please remove strict option from ResponseValidation")
-        end
+        @strict = options[:strict]
         @validate_success_only = @schema.validator_option.validate_success_only
       end
 
@@ -19,7 +16,7 @@ module Committee
 
         begin
           v = build_schema_validator(request)
-          v.response_validate(status, headers, response) if v.link_exist? && self.class.validate?(status, validate_success_only)
+          v.response_validate(status, headers, response, @strict) if v.link_exist? && self.class.validate?(status, validate_success_only)
 
         rescue Committee::InvalidResponse
           handle_exception($!, request.env)
@@ -38,21 +35,23 @@ module Committee
 
       class << self
         def validate?(status, validate_success_only)
-          status != 204 && (!validate_success_only || (200...300).include?(status))
+          case status
+          when 204
+            false
+          when 200..299
+            true
+          when 304
+            false
+          else
+            !validate_success_only
+          end
         end
       end
 
       private
 
       def handle_exception(e, env)
-        return unless @error_handler
-
-        if @error_handler.arity > 1
-          @error_handler.call(e, env)
-        else
-          Committee.warn_deprecated('Using `error_handler.call(exception)` is deprecated and will be change to `error_handler.call(exception, request.env)` in next major version.')
-          @error_handler.call(e)
-        end
+        @error_handler.call(e, env) if @error_handler
       end
     end
   end

data/lib/committee/request_unpacker.rb

@@ -27,7 +27,7 @@ module Committee
       @optimistic_json    = options[:optimistic_json]
     end
 
-    # reutrn params and is_form_params
+    # return params and is_form_params
     def unpack_request_params(request)
       # if Content-Type is empty or JSON, and there was a request body, try to
       # interpret it as JSON

data/lib/committee/schema_validator/hyper_schema/response_validator.rb

@@ -14,7 +14,7 @@ module Committee
         end
 
         def call(status, headers, data)
-          unless status == 204 # 204 No Content
+          unless [204, 304].include?(status) # 204 No Content or 304 Not Modified
             response = Rack::Response.new(data, status, headers)
             check_content_type!(response)
           end
@@ -48,9 +48,15 @@ module Committee
         private
 
         def response_media_type(response)
-          response.content_type.to_s.split(";").first.to_s
+          if response.respond_to?(:media_type)
+            response.media_type.to_s
+          else
+            # for rack compatibility. In rack v 1.5.0, Rack::Response doesn't have media_type
+            response.content_type.to_s.split(";").first.to_s
+          end
         end
 
+
         def check_content_type!(response)
           if @link.media_type
             unless Rack::Mime.match?(response_media_type(response), @link.media_type)

data/lib/committee/schema_validator/open_api_3/operation_wrapper.rb

@@ -39,18 +39,12 @@ module Committee
           raise Committee::InvalidResponse.new(e.message, original_error: e)
         end
 
-        def validate_request_params(params, headers, validator_option)
+        def validate_request_params(path_params, query_params, body_params, headers, validator_option)
           ret, err = case request_operation.http_method
-                when 'get'
-                  validate_get_request_params(params, headers, validator_option)
-                when 'post'
-                  validate_post_request_params(params, headers, validator_option)
-                when 'put'
-                  validate_post_request_params(params, headers, validator_option)
-                when 'patch'
-                  validate_post_request_params(params, headers, validator_option)
-                when 'delete'
-                  validate_get_request_params(params, headers, validator_option)
+                when 'get', 'delete', 'head'
+                  validate_get_request_params(path_params, query_params, headers, validator_option)
+                when 'post', 'put', 'patch', 'options'
+                  validate_post_request_params(path_params, query_params, body_params, headers, validator_option)
                 else
                   raise "Committee OpenAPI3 not support #{request_operation.http_method} method"
                 end
@@ -58,6 +52,10 @@ module Committee
           ret
         end
 
+        def optional_body?
+          !request_operation.operation_object&.request_body&.required
+        end
+
         def valid_request_content_type?(content_type)
           if (request_body = request_operation.operation_object&.request_body)
             !request_body.select_media_type(content_type).nil?
@@ -80,28 +78,17 @@ module Committee
         #   @return [OpenAPIParser::RequestOperation]
 
         # @return [OpenAPIParser::SchemaValidator::Options]
-        def build_openapi_parser_path_option(validator_option)
-          coerce_value = validator_option.coerce_path_params
-          datetime_coerce_class = validator_option.coerce_date_times ? DateTime : nil
-          validate_header = validator_option.check_header
-          OpenAPIParser::SchemaValidator::Options.new(coerce_value: coerce_value,
-                                                      datetime_coerce_class: datetime_coerce_class,
-                                                      validate_header: validate_header)
+        def build_openapi_parser_body_option(validator_option)
+          build_openapi_parser_option(validator_option, validator_option.coerce_form_params)
         end
 
         # @return [OpenAPIParser::SchemaValidator::Options]
-        def build_openapi_parser_post_option(validator_option)
-          coerce_value = validator_option.coerce_form_params
-          datetime_coerce_class = validator_option.coerce_date_times ? DateTime : nil
-          validate_header = validator_option.check_header
-          OpenAPIParser::SchemaValidator::Options.new(coerce_value: coerce_value,
-                                                      datetime_coerce_class: datetime_coerce_class,
-                                                      validate_header: validate_header)
+        def build_openapi_parser_path_option(validator_option)
+          build_openapi_parser_option(validator_option, validator_option.coerce_query_params)
         end
 
         # @return [OpenAPIParser::SchemaValidator::Options]
-        def build_openapi_parser_get_option(validator_option)
-          coerce_value = validator_option.coerce_query_params
+        def build_openapi_parser_option(validator_option, coerce_value)
           datetime_coerce_class = validator_option.coerce_date_times ? DateTime : nil
           validate_header = validator_option.check_header
           OpenAPIParser::SchemaValidator::Options.new(coerce_value: coerce_value,
@@ -109,24 +96,40 @@ module Committee
                                                       validate_header: validate_header)
         end
 
-        def validate_get_request_params(params, headers, validator_option)
+        def validate_get_request_params(path_params, query_params, headers, validator_option)
           # bad performance because when we coerce value, same check
-          request_operation.validate_request_parameter(params, headers, build_openapi_parser_get_option(validator_option))
+          validate_path_and_query_params(path_params, query_params, headers, validator_option)
         rescue OpenAPIParser::OpenAPIError => e
           raise Committee::InvalidRequest.new(e.message, original_error: e)
         end
 
-        def validate_post_request_params(params, headers, validator_option)
+        def validate_post_request_params(path_params, query_params, body_params, headers, validator_option)
           content_type = headers['Content-Type'].to_s.split(";").first.to_s
 
           # bad performance because when we coerce value, same check
-          schema_validator_options = build_openapi_parser_post_option(validator_option)
-          request_operation.validate_request_parameter(params, headers, schema_validator_options)
-          request_operation.validate_request_body(content_type, params, schema_validator_options)
+          validate_path_and_query_params(path_params, query_params, headers, validator_option)
+          request_operation.validate_request_body(content_type, body_params, build_openapi_parser_body_option(validator_option))
         rescue => e
           raise Committee::InvalidRequest.new(e.message, original_error: e)
         end
 
+        def validate_path_and_query_params(path_params, query_params, headers, validator_option)
+          # it's currently impossible to validate path params and query params separately
+          # so we have to resort to this workaround
+
+          path_keys = path_params.keys.to_set
+          query_keys = query_params.keys.to_set
+
+          merged_params = query_params.merge(path_params)
+
+          request_operation.validate_request_parameter(merged_params, headers, build_openapi_parser_path_option(validator_option))
+
+          merged_params.each do |k, v|
+            path_params[k] = v if path_keys.include?(k)
+            query_params[k] = v if query_keys.include?(k)
+          end
+        end
+
         def response_validate_options(strict, check_header)
           ::OpenAPIParser::SchemaValidator::ResponseValidateOptions.new(strict: strict, validate_header: check_header)
         end

data/lib/committee/schema_validator/open_api_3/request_validator.rb

@@ -11,11 +11,11 @@ module Committee
           @validator_option = validator_option
         end
 
-        def call(request, params, headers)
+        def call(request, path_params, query_params, body_params, headers)
           content_type = ::Committee::SchemaValidator.request_media_type(request)
           check_content_type(request, content_type) if @validator_option.check_content_type
 
-          @operation_object.validate_request_params(params, headers, @validator_option)
+          @operation_object.validate_request_params(path_params, query_params, body_params, headers, @validator_option)
         end
 
         private
@@ -24,6 +24,7 @@ module Committee
           # support post, put, patch only
           return true unless request.post? || request.put? || request.patch?
           return true if @operation_object.valid_request_content_type?(content_type)
+          return true if @operation_object.optional_body? && empty_request?(request)
 
           message = if valid_content_types.size > 1
                       types = valid_content_types.map {|x| %{"#{x}"} }.join(', ')
@@ -37,6 +38,14 @@ module Committee
         def valid_content_types
           @operation_object&.request_content_types
         end
+
+        def empty_request?(request)
+          return true if !request.body
+
+          data = request.body.read
+          request.body.rewind
+          data.empty?
+        end
       end
     end
   end

data/lib/committee/schema_validator/open_api_3.rb

@@ -17,7 +17,7 @@ module Committee
         request_unpack(request)
         request_schema_validation(request)
 
-        copy_coerced_data_to_query_hash(request)
+        copy_coerced_data_to_params(request)
       end
 
       def response_validate(status, headers, response, test_method = false)
@@ -34,6 +34,7 @@ module Committee
           full_body
         end
 
+        # TODO: refactoring name
         strict = test_method
         Committee::SchemaValidator::OpenAPI3::ResponseValidator.
             new(@operation_object, validator_option).
@@ -57,7 +58,19 @@ module Committee
         return unless @operation_object
 
         validator = Committee::SchemaValidator::OpenAPI3::RequestValidator.new(@operation_object, validator_option: validator_option)
-        validator.call(request, request.env[validator_option.params_key], header(request))
+        validator.call(request, path_params(request), query_params(request), body_params(request), header(request))
+      end
+
+      def path_params(request)
+        request.env[validator_option.path_hash_key]
+      end
+
+      def query_params(request)
+        request.env[validator_option.query_hash_key]
+      end
+
+      def body_params(request)
+        request.env[validator_option.request_body_hash_key]
       end
 
       def header(request)
@@ -79,30 +92,22 @@ module Committee
         request.env[validator_option.path_hash_key] = coerce_path_params
 
         query_param = unpacker.unpack_query_params(request)
+        query_param.merge!(request_param) if request.get? && validator_option.allow_get_body
+        request.env[validator_option.query_hash_key] = query_param
+      end
 
+      def copy_coerced_data_to_params(request)
         order = if validator_option.parameter_overwite_by_rails_rule
           # (high priority) path_hash_key -> query_param -> request_body_hash          
-          [request.env[validator_option.request_body_hash_key], query_param, request.env[validator_option.path_hash_key]]
+          [validator_option.request_body_hash_key, validator_option.query_hash_key, validator_option.path_hash_key]
         else
           # (high priority) path_hash_key -> request_body_hash -> query_param
-          [query_param, request.env[validator_option.request_body_hash_key], request.env[validator_option.path_hash_key]]
+          [validator_option.query_hash_key, validator_option.request_body_hash_key, validator_option.path_hash_key]
         end
 
         request.env[validator_option.params_key] = Committee::Utils.indifferent_hash
-        order.each do |param|
-          request.env[validator_option.params_key].merge!(Committee::Utils.deep_copy(param))
-        end
-      end
-
-      def copy_coerced_data_to_query_hash(request)
-        return if request.env["rack.request.query_hash"].nil? || request.env["rack.request.query_hash"].empty?
-
-        query_hash_key = @validator_option.query_hash_key
-        return unless query_hash_key
-
-        request.env[query_hash_key] = {} unless request.env[query_hash_key]
-        request.env["rack.request.query_hash"].keys.each do |k|
-          request.env[query_hash_key][k] = request.env[validator_option.params_key][k]
+        order.each do |key|
+          request.env[validator_option.params_key].merge!(Committee::Utils.deep_copy(request.env[key]))
         end
       end
     end

data/lib/committee/schema_validator/option.rb

@@ -27,16 +27,11 @@ module Committee
                   :path_hash_key,
                   :prefix
 
-      def initialize(options, schema, schema_type, is_request)
+      def initialize(options, schema, schema_type)
         # Non-boolean options
         @headers_key         = options[:headers_key]    || "committee.headers"
         @params_key          = options[:params_key]     || "committee.params"
-        @query_hash_key      = if options[:query_hash_key].nil?
-          Committee.warn_deprecated('Committee: please set query_hash_key = "rack.request.query_hash" because we\'ll change default value to "committee.query_hash" in next major version.') 
-          'rack.request.query_hash'
-        else
-          options.fetch(:query_hash_key)
-        end
+        @query_hash_key      = options[:query_hash_key] || "committee.query_hash"
         @path_hash_key      = options[:path_hash_key] || "committee.path_hash"
         @request_body_hash_key = options[:request_body_hash_key] || "committee.request_body_hash"
 
@@ -49,20 +44,8 @@ module Committee
         @check_header        = options.fetch(:check_header, true)
         @coerce_recursive    = options.fetch(:coerce_recursive, true)
         @optimistic_json     = options.fetch(:optimistic_json, false)
-        @parse_response_by_content_type = if options[:parse_response_by_content_type].nil?
-          if !is_request
-            Committee.warn_deprecated('Committee: please set parse_response_by_content_type = false because we\'ll change default value in next major version.') 
-          end
-          false
-        else
-          options.fetch(:parse_response_by_content_type)
-        end
-        @parameter_overwite_by_rails_rule      = if options[:parameter_overwite_by_rails_rule].nil?
-          Committee.warn_deprecated('Committee: please set parameter_overwite_by_rails_rule = false because we\'ll change default value to "true" in next major version.') 
-          false
-        else
-          options.fetch(:parameter_overwite_by_rails_rule)
-        end
+        @parse_response_by_content_type = options.fetch(:parse_response_by_content_type, true)
+        @parameter_overwite_by_rails_rule = options.fetch(:parameter_overwite_by_rails_rule, true)
 
         # Boolean options and have a different value by default
         @allow_get_body      = options.fetch(:allow_get_body, schema.driver.default_allow_get_body)

data/lib/committee/schema_validator.rb

@@ -4,7 +4,7 @@ module Committee
   module SchemaValidator
     class << self
       def request_media_type(request)
-        request.content_type.to_s.split(";").first.to_s
+        request.media_type.to_s
       end
 
       # @param [String] prefix

data/lib/committee/test/methods.rb

@@ -26,7 +26,7 @@ module Committee
         status, headers, body = response_data
 
         if expected_status.nil?
-          Committee.warn_deprecated('Pass expected response status code to check it against the corresponding schema explicitly.')
+          Committee.need_good_option('Pass expected response status code to check it against the corresponding schema explicitly.')
         elsif expected_status != status
           response = "Expected `#{expected_status}` status code, but it was `#{status}`."
           raise Committee::InvalidResponse.new(response)
@@ -61,7 +61,7 @@ module Committee
       end
 
       def router
-        @router ||= schema.build_router(committee_options, true)
+        @router ||= schema.build_router(committee_options)
       end
 
       def schema_validator
@@ -77,12 +77,7 @@ module Committee
       end
 
       def old_behavior
-        old_assert_behavior = committee_options.fetch(:old_assert_behavior, nil)
-        if old_assert_behavior.nil?
-          Committee.warn_deprecated('Now assert_schema_conform check response schema only. but we will change check request and response in future major version. so if you want to conform response only, please use assert_response_schema_confirm, or you can suppress this message and keep old behavior by setting old_assert_behavior=true.')
-          old_assert_behavior = true
-        end
-        old_assert_behavior
+        committee_options.fetch(:old_assert_behavior, false)
       end
     end
   end

data/lib/committee/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Committee
+    VERSION = '5.0.0'.freeze
+end

data/lib/committee.rb

@@ -6,6 +6,8 @@ require "json_schema"
 require "rack"
 require 'openapi_parser'
 
+require_relative "committee/version"
+
 module Committee
   def self.debug?
     ENV["COMMITTEE_DEBUG"]
@@ -15,8 +17,13 @@ module Committee
     $stderr.puts(message) if debug?
   end
 
-  def self.warn_deprecated(message)
-    warn("[DEPRECATION] #{message}")
+  def self.need_good_option(message)
+    warn(message)
+  end
+
+  def self.warn_deprecated_until_6(cond, message)
+    raise "remove deprecated!"  unless Committee::VERSION.start_with?("5")
+    warn("[DEPRECATION] #{message}") if cond
   end
 end