committee 5.5.0 → 5.5.1

data/lib/committee/schema_validator/hyper_schema.rb

@@ -28,8 +28,13 @@ module Committee
 
         data = {}
         unless full_body.empty?
-          parse_to_json = !validator_option.parse_response_by_content_type ||
-                          headers.fetch('Content-Type', nil)&.start_with?('application/json')
+          parse_to_json = if validator_option.parse_response_by_content_type
+                            content_type_key = headers.keys.detect { |k| k.casecmp?('Content-Type') }
+            headers.fetch(content_type_key, nil)&.start_with?('application/json')
+          else
+            true
+          end
+
           data = JSON.parse(full_body) if parse_to_json
         end
 
@@ -42,71 +47,71 @@ module Committee
 
       private
 
-        def coerce_path_params
-          return {} unless link_exist?
+      def coerce_path_params
+        return {} unless link_exist?
 
-          Committee::SchemaValidator::HyperSchema::StringParamsCoercer.new(param_matches, link.schema, coerce_recursive: validator_option.coerce_recursive).call!
-          param_matches
-        end
+        Committee::SchemaValidator::HyperSchema::StringParamsCoercer.new(param_matches, link.schema, coerce_recursive: validator_option.coerce_recursive).call!
+        param_matches
+      end
 
-        def coerce_query_params(request)
-          return unless link_exist?
-          return if request.GET.nil? || link.schema.nil?
+      def coerce_query_params(request)
+        return unless link_exist?
+        return if request.GET.nil? || link.schema.nil?
 
-          Committee::SchemaValidator::HyperSchema::StringParamsCoercer.new(request.GET, link.schema, coerce_recursive: validator_option.coerce_recursive).call!
-        end
+        Committee::SchemaValidator::HyperSchema::StringParamsCoercer.new(request.GET, link.schema, coerce_recursive: validator_option.coerce_recursive).call!
+      end
 
-        def request_unpack(request)
-          unpacker = Committee::RequestUnpacker.new(
-            allow_form_params:  validator_option.allow_form_params,
-            allow_get_body:     validator_option.allow_get_body,
-            allow_query_params: validator_option.allow_query_params,
-            optimistic_json:    validator_option.optimistic_json,
-          )
-
-          request.env[validator_option.headers_key] = unpacker.unpack_headers(request)
-
-          # Attempts to coerce parameters that appear in a link's URL to Ruby
-          # types that can be validated with a schema.
-          param_matches_hash = validator_option.coerce_path_params ? coerce_path_params : {}
-
-          # Attempts to coerce parameters that appear in a query string to Ruby
-          # types that can be validated with a schema.
-          coerce_query_params(request) if validator_option.coerce_query_params
-
-          query_param = unpacker.unpack_query_params(request)
-          request_param, is_form_params = unpacker.unpack_request_params(request)
-          coerce_form_params(request_param) if validator_option.coerce_form_params && is_form_params
-          request.env[validator_option.request_body_hash_key] = request_param
-
-          request.env[validator_option.params_key] = Committee::Utils.indifferent_hash
-          request.env[validator_option.params_key].merge!(Committee::Utils.deep_copy(query_param))
-          request.env[validator_option.params_key].merge!(Committee::Utils.deep_copy(request_param))
-          request.env[validator_option.params_key].merge!(Committee::Utils.deep_copy(param_matches_hash))
-        end
+      def request_unpack(request)
+        unpacker = Committee::RequestUnpacker.new(
+          allow_form_params:  validator_option.allow_form_params,
+          allow_get_body:     validator_option.allow_get_body,
+          allow_query_params: validator_option.allow_query_params,
+          optimistic_json:    validator_option.optimistic_json,
+        )
+
+        request.env[validator_option.headers_key] = unpacker.unpack_headers(request)
+
+        # Attempts to coerce parameters that appear in a link's URL to Ruby
+        # types that can be validated with a schema.
+        param_matches_hash = validator_option.coerce_path_params ? coerce_path_params : {}
+
+        # Attempts to coerce parameters that appear in a query string to Ruby
+        # types that can be validated with a schema.
+        coerce_query_params(request) if validator_option.coerce_query_params
+
+        query_param = unpacker.unpack_query_params(request)
+        request_param, is_form_params = unpacker.unpack_request_params(request)
+        coerce_form_params(request_param) if validator_option.coerce_form_params && is_form_params
+        request.env[validator_option.request_body_hash_key] = request_param
+
+        request.env[validator_option.params_key] = Committee::Utils.indifferent_hash
+        request.env[validator_option.params_key].merge!(Committee::Utils.deep_copy(query_param))
+        request.env[validator_option.params_key].merge!(Committee::Utils.deep_copy(request_param))
+        request.env[validator_option.params_key].merge!(Committee::Utils.deep_copy(param_matches_hash))
+      end
 
-        def coerce_form_params(parameter)
-          return unless link_exist?
-          return unless link.schema
-          Committee::SchemaValidator::HyperSchema::StringParamsCoercer.new(parameter, link.schema).call!
-        end
+      def coerce_form_params(parameter)
+        return unless link_exist?
+        return unless link.schema
+        Committee::SchemaValidator::HyperSchema::StringParamsCoercer.new(parameter, link.schema).call!
+      end
 
-        def request_schema_validation(request)
-          return unless link_exist?
-          validator = Committee::SchemaValidator::HyperSchema::RequestValidator.new(link, check_content_type: validator_option.check_content_type, check_header: validator_option.check_header)
-          validator.call(request, request.env[validator_option.params_key], request.env[validator_option.headers_key])
-        end
+      def request_schema_validation(request)
+        return unless link_exist?
+        validator = Committee::SchemaValidator::HyperSchema::RequestValidator.new(link, check_content_type: validator_option.check_content_type, check_header: validator_option.check_header)
+        validator.call(request, request.env[validator_option.params_key], request.env[validator_option.headers_key])
+      end
 
-        def parameter_coerce!(request, link, coerce_key)
-          return unless link_exist?
+      def parameter_coerce!(request, link, coerce_key)
+        return unless link_exist?
 
-          Committee::SchemaValidator::HyperSchema::ParameterCoercer.
-              new(request.env[coerce_key],
-                  link.schema,
-                  coerce_date_times: validator_option.coerce_date_times,
-                  coerce_recursive: validator_option.coerce_recursive).
-              call!
-        end
+        Committee::SchemaValidator::HyperSchema::ParameterCoercer.
+          new(request.env[coerce_key],
+            link.schema,
+            coerce_date_times: validator_option.coerce_date_times,
+            coerce_recursive: validator_option.coerce_recursive).
+          call!
+      end
     end
   end
 end

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

@@ -27,7 +27,7 @@ module Committee
           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(', ')
+                      types = valid_content_types.map { |x| %{"#{x}"} }.join(', ')
                       %{"Content-Type" request header must be set to any of the following: [#{types}].}
                     else
                       %{"Content-Type" request header must be set to "#{valid_content_types.first}".}

data/lib/committee/schema_validator/open_api_3.rb

@@ -26,10 +26,15 @@ module Committee
           full_body << chunk
         end
 
-        parse_to_json = !validator_option.parse_response_by_content_type || 
-                        headers.fetch('Content-Type', nil)&.start_with?('application/json')
+        parse_to_json = if validator_option.parse_response_by_content_type
+                          content_type_key = headers.keys.detect { |k| k.casecmp?('Content-Type') }
+          headers.fetch(content_type_key, nil)&.start_with?('application/json')
+        else
+          true
+        end
+
         data = if parse_to_json
-          full_body.empty? ? {} : JSON.parse(full_body)
+                 full_body.empty? ? {} : JSON.parse(full_body)
         else
           full_body
         end
@@ -98,8 +103,8 @@ module Committee
 
       def copy_coerced_data_to_params(request)
         order = if validator_option.parameter_overwrite_by_rails_rule
-          # (high priority) path_hash_key -> query_param -> request_body_hash          
-          [validator_option.request_body_hash_key, validator_option.query_hash_key, validator_option.path_hash_key]
+          # (high priority) path_hash_key -> query_param -> request_body_hash
+                  [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
           [validator_option.query_hash_key, validator_option.request_body_hash_key, validator_option.path_hash_key]

data/lib/committee/schema_validator/option.rb

@@ -21,12 +21,7 @@ module Committee
                   :parameter_overwrite_by_rails_rule
 
       # Non-boolean options:
-      attr_reader :headers_key,
-                  :params_key,
-                  :query_hash_key,
-                  :request_body_hash_key,
-                  :path_hash_key,
-                  :prefix
+      attr_reader :headers_key, :params_key, :query_hash_key, :request_body_hash_key, :path_hash_key, :prefix
 
       def initialize(options, schema, schema_type)
         # Non-boolean options

data/lib/committee/test/schema_coverage.rb

@@ -28,12 +28,7 @@ module Committee
             path_coverage.each do |method, method_coverage|
               responses_coverage = method_coverage['responses']
               responses_coverage.each do |response_status, is_covered|
-                responses << {
-                  path: path_name,
-                  method: method,
-                  status: response_status,
-                  is_covered: is_covered,
-                }
+                responses << { path: path_name, method: method, status: response_status, is_covered: is_covered, }
               end
             end
           end
@@ -98,4 +93,3 @@ module Committee
     end
   end
 end
-

data/lib/committee/utils.rb

@@ -1,28 +1,28 @@
 # frozen_string_literal: true
 
 module Committee
-    module Utils
-        # Creates a Hash with indifferent access.
-        #
-        # (Copied from Sinatra)
-        def self.indifferent_hash
-            Hash.new { |hash,key| hash[key.to_s] if Symbol === key }
-        end
-
-        def self.deep_copy(from)
-            if from.is_a?(Hash)
-                h = Committee::Utils.indifferent_hash
-                from.each_pair do |k, v|
-                h[k] = deep_copy(v)
-                end
-                return h
-            end
+  module Utils
+      # Creates a Hash with indifferent access.
+      #
+      # (Copied from Sinatra)
+    def self.indifferent_hash
+      Hash.new { |hash, key| hash[key.to_s] if Symbol === key }
+    end
 
-            if from.is_a?(Array)
-                return from.map{ |v| deep_copy(v) }
-            end
+    def self.deep_copy(from)
+      if from.is_a?(Hash)
+        h = Committee::Utils.indifferent_hash
+          from.each_pair do |k, v|
+            h[k] = deep_copy(v)
+          end
+          return h
+      end
 
-            return from
+        if from.is_a?(Array)
+          return from.map { |v| deep_copy(v) }
         end
+
+        return from
     end
+  end
 end

data/lib/committee/version.rb

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

data/test/bin/committee_stub_test.rb

@@ -18,11 +18,7 @@ describe Committee::Bin::CommitteeStub do
     parser.parse!(["--help"])
     assert_equal true, options[:help]
 
-    parser.parse!([
-      "--driver", "open_api_2",
-      "--tolerant", "true",
-      "--port", "1234"
-    ])
+    parser.parse!(["--driver", "open_api_2", "--tolerant", "true", "--port", "1234"])
     assert_equal :open_api_2, options[:driver]
     assert_equal true, options[:tolerant]
     assert_equal "1234", options[:port]

data/test/committee_test.rb

@@ -62,7 +62,6 @@ describe Committee do
     end
   end
 
-
   it "doesn't warns on deprecated if cond is false" do
     old_stderr = $stderr
     old_verbose = $VERBOSE

data/test/drivers/hyper_schema/driver_test.rb

@@ -46,4 +46,3 @@ describe Committee::Drivers::HyperSchema::Driver do
     assert_equal false, @driver.default_query_params
   end
 end
-

data/test/drivers/open_api_2/driver_test.rb

@@ -46,8 +46,7 @@ describe Committee::Drivers::OpenAPI2::Driver do
 
   it "names capture groups into href regexes" do
     schema = @driver.parse(open_api_2_data)
-    assert_equal %r{^\/api\/pets\/(?<id>[^\/]+)$}.inspect,
-      schema.routes["DELETE"][0][0].inspect
+    assert_equal %r{^\/api\/pets\/(?<id>[^\/]+)$}.inspect, schema.routes["DELETE"][0][0].inspect
   end
 
   it "prefers a 200 response first" do
@@ -153,4 +152,3 @@ describe Committee::Drivers::OpenAPI2::Driver do
     }
   end
 end
-

data/test/drivers/open_api_2/header_schema_builder_test.rb

@@ -4,15 +4,7 @@ require "test_helper"
 
 describe Committee::Drivers::OpenAPI2::HeaderSchemaBuilder do
   it "returns schema data for header" do
-    data = {
-      "parameters" => [
-        {
-          "name" => "AUTH_TOKEN",
-          "type" => "string",
-          "in" => "header",
-        }
-      ]
-    }
+    data = { "parameters" => [{ "name" => "AUTH_TOKEN", "type" => "string", "in" => "header", }] }
     schema = call(data)
 
     assert_equal ["string"], schema.properties["AUTH_TOKEN"].type

data/test/drivers/open_api_2/link_test.rb

@@ -11,7 +11,7 @@ describe Committee::Drivers::OpenAPI2::Link do
     @link.method = "GET"
     @link.status_success = 200
     @link.schema = { "title" => "input" }
-    @link.target_schema = { "title" => "target" }
+    @link.target_schemas = { 200 => { "title" => "target" } }
   end
 
   it "uses set #enc_type" do
@@ -49,4 +49,3 @@ describe Committee::Drivers::OpenAPI2::Link do
     assert_equal({ "title" => "target" }, @link.target_schema)
   end
 end
-

data/test/drivers/open_api_2/parameter_schema_builder_test.rb

@@ -7,14 +7,7 @@ describe Committee::Drivers::OpenAPI2::ParameterSchemaBuilder do
   end
 
   it "reflects a basic type into a schema" do
-    data = {
-      "parameters" => [
-        {
-          "name" => "limit",
-          "type" => "integer",
-        }
-      ]
-    }
+    data = { "parameters" => [{ "name" => "limit", "type" => "integer", }] }
     schema, schema_data = call(data)
 
     assert_nil schema_data
@@ -37,14 +30,7 @@ describe Committee::Drivers::OpenAPI2::ParameterSchemaBuilder do
   end
 
   it "reflects a required property into a schema" do
-    data = {
-      "parameters" => [
-        {
-          "name" => "limit",
-          "required" => true,
-        }
-      ]
-    }
+    data = { "parameters" => [{ "name" => "limit", "required" => true, }] }
     schema, schema_data = call(data)
 
     assert_nil schema_data
@@ -77,15 +63,7 @@ describe Committee::Drivers::OpenAPI2::ParameterSchemaBuilder do
   end
 
   it "reflects a enum property into a schema" do
-    data = {
-      "parameters" => [
-        {
-          "name" => "type",
-          "type" => "string",
-          "enum" => ["hoge", "fuga"]
-        }
-      ]
-    }
+    data = { "parameters" => [{ "name" => "type", "type" => "string", "enum" => ["hoge", "fuga"] }] }
     schema, schema_data = call(data)
 
     assert_nil schema_data
@@ -157,12 +135,7 @@ describe Committee::Drivers::OpenAPI2::ParameterSchemaBuilder do
   end
 
   it "requires that certain fields are present" do
-    data = {
-      "parameters" => [
-        {
-        }
-      ]
-    }
+    data = { "parameters" => [{}] }
     e = assert_raises ArgumentError do
       call(data)
     end
@@ -170,23 +143,11 @@ describe Committee::Drivers::OpenAPI2::ParameterSchemaBuilder do
   end
 
   it "requires that body parameters not be mixed with form parameters" do
-    data = {
-      "parameters" => [
-        {
-          "name" => "payload",
-          "in" => "body",
-        },
-        {
-          "name" => "limit",
-          "in" => "form",
-        },
-      ]
-    }
+    data = { "parameters" => [{ "name" => "payload", "in" => "body", }, { "name" => "limit", "in" => "form", },] }
     e = assert_raises ArgumentError do
       call(data)
     end
-    assert_equal "Committee: can't mix body parameter with form parameters.",
-      e.message
+    assert_equal "Committee: can't mix body parameter with form parameters.", e.message
   end
 
   def call(data)

data/test/drivers/open_api_3/driver_test.rb

@@ -52,31 +52,31 @@ describe Committee::Drivers::OpenAPI3::Driver do
         it "gets a nested template path" do
           obj = open_api_3_schema.operation_object("/path_template_test/abc/nested", "get")
           assert_equal "/path_template_test/{template_name}/nested", obj.original_path
-          assert_equal({"template_name"=>"abc"}, obj.path_params)
+          assert_equal({ "template_name" => "abc" }, obj.path_params)
         end
 
         it "gets a double nested template path" do
           obj = open_api_3_schema.operation_object("/path_template_test/test/nested/abc", "get")
           assert_equal "/path_template_test/{template_name}/nested/{nested_parameter}", obj.original_path
-          assert_equal({"template_name"=>"test", "nested_parameter" => "abc"}, obj.path_params)
+          assert_equal({ "template_name" => "test", "nested_parameter" => "abc" }, obj.path_params)
         end
 
         it "gets a twice nested template path" do
           obj = open_api_3_schema.operation_object("/path_template_test/test/abc", "get")
           assert_equal "/path_template_test/{template_name}/{nested_parameter}", obj.original_path
-          assert_equal({"template_name"=>"test", "nested_parameter" => "abc"}, obj.path_params)
+          assert_equal({ "template_name" => "test", "nested_parameter" => "abc" }, obj.path_params)
         end
 
         it "gets a twice nested concrete path" do
           obj = open_api_3_schema.operation_object("/path_template_test/test/abc/finish", "get")
           assert_equal "/path_template_test/{template_name}/{nested_parameter}/finish", obj.original_path
-          assert_equal({"template_name"=>"test", "nested_parameter" => "abc"}, obj.path_params)
+          assert_equal({ "template_name" => "test", "nested_parameter" => "abc" }, obj.path_params)
         end
 
         it "gets an ambiguous path" do
           obj = open_api_3_schema.operation_object("/ambiguous/no_template", "get")
           assert_equal "/{ambiguous}/no_template", obj.original_path
-          assert_equal({"ambiguous"=>"ambiguous"}, obj.path_params)
+          assert_equal({ "ambiguous" => "ambiguous" }, obj.path_params)
         end
       end
     end

data/test/drivers_test.rb

@@ -3,11 +3,7 @@
 require "test_helper"
 
 describe Committee::Drivers do
-  DRIVERS = [
-    :hyper_schema,
-    :open_api_2,
-    :open_api_3,
-  ].freeze
+  DRIVERS = [:hyper_schema, :open_api_2, :open_api_3,].freeze
 
   it "gets driver with .driver_from_name" do
     DRIVERS.each do |name|
@@ -37,20 +33,20 @@ describe Committee::Drivers do
     end
 
     it 'loads OpenAPI 3' do
-      s = Committee::Drivers.load_from_file(open_api_3_schema_path, parser_options:{strict_reference_validation: true})
+      s = Committee::Drivers.load_from_file(open_api_3_schema_path, parser_options: { strict_reference_validation: true })
       assert_kind_of Committee::Drivers::Schema, s
       assert_kind_of Committee::Drivers::OpenAPI3::Schema, s
     end
 
     it 'load OpenAPI 3 (patch version 3.0.1)' do
-      s = Committee::Drivers.load_from_file(open_api_3_0_1_schema_path, parser_options:{strict_reference_validation: true})
+      s = Committee::Drivers.load_from_file(open_api_3_0_1_schema_path, parser_options: { strict_reference_validation: true })
       assert_kind_of Committee::Drivers::Schema, s
       assert_kind_of Committee::Drivers::OpenAPI3::Schema, s
     end
 
     it 'fails to load OpenAPI 3.1+' do
       e = assert_raises(Committee::OpenAPI3Unsupported) do
-        Committee::Drivers.load_from_file(open_api_3_1_schema_path, parser_options:{strict_reference_validation: true})
+        Committee::Drivers.load_from_file(open_api_3_1_schema_path, parser_options: { strict_reference_validation: true })
       end
       assert_equal 'Committee does not support OpenAPI 3.1+ yet', e.message
     end
@@ -64,13 +60,13 @@ describe Committee::Drivers do
 
     # This test can be removed when the test above (raising on invalid reference) becomes default behavior?
     it 'allows loading OpenAPI 3 with invalid reference as existing behavior' do
-      s = Committee::Drivers.load_from_file(open_api_3_invalid_reference_path, parser_options:{strict_reference_validation: false})
+      s = Committee::Drivers.load_from_file(open_api_3_invalid_reference_path, parser_options: { strict_reference_validation: false })
       assert_kind_of Committee::Drivers::OpenAPI3::Schema, s
     end
 
     it 'errors on an unsupported file extension' do
       e = assert_raises(StandardError) do
-        Committee::Drivers.load_from_file('test.xml', parser_options:{strict_reference_validation: true})
+        Committee::Drivers.load_from_file('test.xml', parser_options: { strict_reference_validation: true })
       end
       assert_equal "Committee only supports the following file extensions: '.json', '.yaml', '.yml'", e.message
     end
@@ -79,24 +75,24 @@ describe Committee::Drivers do
       describe 'when loading the same file' do
         it 'returns the same object when the options are identical' do
           assert_equal(
-            Committee::Drivers.load_from_file(open_api_3_schema_path, parser_options:{strict_reference_validation: true}).object_id,
-            Committee::Drivers.load_from_file(open_api_3_schema_path, parser_options:{strict_reference_validation: true}).object_id,
+            Committee::Drivers.load_from_file(open_api_3_schema_path, parser_options: { strict_reference_validation: true }).object_id,
+            Committee::Drivers.load_from_file(open_api_3_schema_path, parser_options: { strict_reference_validation: true }).object_id,
           )
         end
 
         it 'returns different objects if the options are different' do
           refute_equal(
-            Committee::Drivers.load_from_file(open_api_3_schema_path, parser_options:{strict_reference_validation: true}).object_id,
-            Committee::Drivers.load_from_file(open_api_3_schema_path, parser_options:{strict_reference_validation: false}).object_id,
+            Committee::Drivers.load_from_file(open_api_3_schema_path, parser_options: { strict_reference_validation: true }).object_id,
+            Committee::Drivers.load_from_file(open_api_3_schema_path, parser_options: { strict_reference_validation: false }).object_id,
           )
         end
 
         it 'returns different objects if the file contents have changed' do
-          object_id = Committee::Drivers.load_from_file(open_api_3_schema_path, parser_options:{strict_reference_validation: true}).object_id
+          object_id = Committee::Drivers.load_from_file(open_api_3_schema_path, parser_options: { strict_reference_validation: true }).object_id
           original_file_contents = File.read(open_api_3_schema_path)
           File.write(open_api_3_schema_path, original_file_contents + "\n")
           refute_equal(
-            Committee::Drivers.load_from_file(open_api_3_schema_path, parser_options:{strict_reference_validation: true}).object_id,
+            Committee::Drivers.load_from_file(open_api_3_schema_path, parser_options: { strict_reference_validation: true }).object_id,
             object_id,
           )
           File.write(open_api_3_schema_path, original_file_contents)
@@ -107,13 +103,13 @@ describe Committee::Drivers do
 
   describe 'load_from_json(schema_path)' do
     it 'loads OpenAPI2' do
-      s = Committee::Drivers.load_from_json(open_api_2_schema_path, parser_options:{strict_reference_validation: true})
+      s = Committee::Drivers.load_from_json(open_api_2_schema_path, parser_options: { strict_reference_validation: true })
       assert_kind_of Committee::Drivers::Schema, s
       assert_kind_of Committee::Drivers::OpenAPI2::Schema, s
     end
 
     it 'loads Hyper-Schema' do
-      s = Committee::Drivers.load_from_json(hyper_schema_schema_path, parser_options:{strict_reference_validation: true})
+      s = Committee::Drivers.load_from_json(hyper_schema_schema_path, parser_options: { strict_reference_validation: true })
       assert_kind_of Committee::Drivers::Schema, s
       assert_kind_of Committee::Drivers::HyperSchema::Schema, s
     end
@@ -121,7 +117,7 @@ describe Committee::Drivers do
 
   describe 'load_from_yaml(schema_path)' do
     it 'loads OpenAPI3' do
-      s = Committee::Drivers.load_from_yaml(open_api_3_schema_path, parser_options:{strict_reference_validation: true})
+      s = Committee::Drivers.load_from_yaml(open_api_3_schema_path, parser_options: { strict_reference_validation: true })
       assert_kind_of Committee::Drivers::Schema, s
       assert_kind_of Committee::Drivers::OpenAPI3::Schema, s
     end
@@ -129,7 +125,7 @@ describe Committee::Drivers do
 
   describe 'load_from_data(schema_path)' do
     it 'loads OpenAPI3' do
-      s = Committee::Drivers.load_from_data(open_api_3_data, parser_options:{strict_reference_validation: false})
+      s = Committee::Drivers.load_from_data(open_api_3_data, parser_options: { strict_reference_validation: false })
       assert_kind_of Committee::Drivers::Schema, s
       assert_kind_of Committee::Drivers::OpenAPI3::Schema, s
     end
@@ -172,17 +168,13 @@ describe Committee::Drivers::Driver do
       e = assert_raises do
         driver.send(name, *args)
       end
-      assert_equal "needs implementation", e.message,
-        "Incorrect error message while sending #{name}: #{e.message}"
+      assert_equal "needs implementation", e.message, "Incorrect error message while sending #{name}: #{e.message}"
     end
   end
 end
 
 describe Committee::Drivers::Schema do
-  SCHEMA_METHODS = {
-    driver: [],
-    build_router: [validator_option: nil, prefix: nil]
-  }
+  SCHEMA_METHODS = { driver: [], build_router: [validator_option: nil, prefix: nil] }
 
   it "has a set of abstract methods" do
     schema = Committee::Drivers::Schema.new
@@ -190,8 +182,7 @@ describe Committee::Drivers::Schema do
       e = assert_raises do
         schema.send(name, *args)
       end
-      assert_equal "needs implementation", e.message,
-        "Incorrect error message while sending #{name}: #{e.message}"
+      assert_equal "needs implementation", e.message, "Incorrect error message while sending #{name}: #{e.message}"
     end
   end
 end