committee 5.5.0 → 5.5.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 426a690ac272e53e30d9572a33564ea8cb7f2e92617e9dcd11b8061e32936b2f
-  data.tar.gz: c335a7d5bb6fe299d6584bf5838ac7972f9be312f431d15db8942cdd3c473cf4
+  metadata.gz: c148e784d74f46205ffc12284b2caabbe9e61104e7ab608a57844b50db5af425
+  data.tar.gz: 9660dc2a5d8f31425e257854fbeb115dacd3f1ba5d205ea1c7e6555c5a9d5c68
 SHA512:
-  metadata.gz: 2e83410d227c6704e208c0bbac5e452a34887921fee1b3f9dbe5c082bbc5861533e49882428e94bb78140d647550047f57b990e7896583a6f18d8ee76d6fdb17
-  data.tar.gz: 610c2002488ee37be624df996fbfbfb9609c416a911583ed3177a0917061908c0efa71324d56b7b90e77ea538b8f6e00c8785c210bd2d8e67c8398177e3269fd
+  metadata.gz: 02e769c6ab664d13e651ac5577bc018615164f0cc047699c3f3245afd99f7cec5667606b613c9abdbc48eb7c8b012daf82279e07adb1dd642ef7920b452d73b4
+  data.tar.gz: 9d9fb9fa77dae324e02890837b569395f94312dd70e815ce9d556e9d6075d58849fa7fef0785ccf4999e7fcb8022ce3cfff85fd3c689ca73e83591cf56b197c6

data/lib/committee/bin/committee_stub.rb

@@ -30,12 +30,7 @@ module Committee
 
       # Gets an option parser for command line arguments.
       def get_options_parser
-        options = {
-          driver: nil,
-          help: false,
-          port: 9292,
-          tolerant: false,
-        }
+        options = { driver: nil, help: false, port: 9292, tolerant: false, }
 
         parser = OptionParser.new do |opts|
           opts.banner = "Usage: rackup [options] [JSON Schema file]"

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

@@ -81,28 +81,21 @@ module Committee
 
         # These are fields that the OpenAPI 2 spec considers mandatory to be
         # included in the document's top level.
-        REQUIRED_FIELDS = [
-          :consumes,
-          :definitions,
-          :paths,
-          :produces,
-          :swagger,
-        ].map(&:to_s).freeze
+        REQUIRED_FIELDS = [:consumes, :definitions, :paths, :produces, :swagger,].map(&:to_s).freeze
 
         def find_best_fit_response(link_data)
           if response_data = link_data["responses"]["200"] || response_data = link_data["responses"][200]
-            [200, response_data]
+            200
           elsif response_data = link_data["responses"]["201"] || response_data = link_data["responses"][201]
-            [201, response_data]
+            201
           else
             # Sort responses so that we can try to prefer any 3-digit status code.
             # If there are none, we'll just take anything from the list.
-            ordered_responses = link_data["responses"].
-              select { |k, v| k.to_s =~ /[0-9]{3}/ }
+            ordered_responses = link_data["responses"].select { |k, v| k.to_s =~ /[0-9]{3}/ }
             if first = ordered_responses.first
-              [first[0].to_i, first[1]]
+              first[0].to_i
             else
-              [nil, nil]
+              nil
             end
           end
         end
@@ -117,9 +110,7 @@ module Committee
           # that all references to it will still have correct paths (i.e. we can
           # still find a resource at '#/definitions/resource' instead of
           # '#/resource').
-          schema = JsonSchema.parse!({
-            "definitions" => data['definitions'],
-          })
+          schema = JsonSchema.parse!({ "definitions" => data['definitions'], })
           schema.expand_references!
           schema.uri = DEFINITIONS_PSEUDO_URI
 
@@ -174,19 +165,16 @@ module Committee
                 schemas_data["properties"][href]["properties"][method] = schema_data
               end
 
-              # Arbitrarily pick one response for the time being. Prefers in order:
-              # a 200, 201, any 3-digit numerical response, then anything at all.
-              status, response_data = find_best_fit_response(link_data)
-              if status
-                link.status_success = status
-
-                # A link need not necessarily specify a target schema.
-                if response_data["schema"]
-                  target_schemas_data["properties"][href]["properties"][method] =
-                    response_data["schema"]
-                end
+              target_schemas_data["properties"][href]["properties"][method] ||= { "properties" => {} }
+              link_data["responses"].each do |key, response_data|
+                status = key.to_i
+                next unless response_data["schema"]
+
+                target_schemas_data["properties"][href]["properties"][method]["properties"][status] = response_data["schema"]
               end
 
+              link.status_success = find_best_fit_response(link_data)
+
               rx = %r{^#{href_to_regex(link.href)}$}
               Committee.log_debug "Created route: #{link.method} #{link.href} (regex #{rx})"
 
@@ -199,10 +187,8 @@ module Committee
           # #parse_definitions!, but what we're doing here is prefixing references
           # with a specialized internal URI so that they can reference definitions
           # from another document in the store.
-          schemas =
-            rewrite_references_and_parse(schemas_data, store)
-          target_schemas =
-            rewrite_references_and_parse(target_schemas_data, store)
+          schemas = rewrite_references_and_parse(schemas_data, store)
+          target_schemas = rewrite_references_and_parse(target_schemas_data, store)
 
           # As noted above, now that we've parsed our aggregate response schema, go
           # back through each link and them their response schema.
@@ -218,8 +204,10 @@ module Committee
               end
 
               # response
-              link.target_schema =
-                target_schemas.properties[link.href].properties[method]
+              link.target_schemas = {}
+              target_schemas.properties[link.href].properties[method].properties.each do |status, schema|
+                link.target_schemas[status] = schema
+              end
             end
           end
 

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

@@ -23,13 +23,20 @@ module Committee
 
         # The link's output schema. i.e. How we validate an endpoint's response
         # data.
-        attr_accessor :target_schema
+        attr_accessor :target_schemas
 
         attr_accessor :header_schema
 
         def rel
           raise "Committee: rel not implemented for OpenAPI"
         end
+
+        def target_schema
+          target_schemas[status_success] ||
+            target_schemas[200] ||
+            target_schemas[201] ||
+            target_schemas.values.first
+        end
       end
     end
   end

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

@@ -17,8 +17,7 @@ module Committee
               check_required_fields!(body_param)
 
               if link_data["parameters"].detect { |p| p["in"] == "form" } != nil
-                raise ArgumentError, "Committee: can't mix body parameter " \
-                  "with form parameters."
+                raise ArgumentError, "Committee: can't mix body parameter with form parameters."
               end
 
               schema_data = body_param["schema"]

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

@@ -10,17 +10,14 @@ module Committee
 
         private
 
-        LINK_REQUIRED_FIELDS = [
-          :name
-        ].map(&:to_s).freeze
+        LINK_REQUIRED_FIELDS = [:name].map(&:to_s).freeze
 
         attr_accessor :link_data
 
         def check_required_fields!(param_data)
           LINK_REQUIRED_FIELDS.each do |field|
             if !param_data[field]
-              raise ArgumentError,
-                    "Committee: no #{field} section in link data."
+              raise ArgumentError, "Committee: no #{field} section in link data."
             end
           end
         end

data/lib/committee/drivers.rb

@@ -65,7 +65,7 @@ module Committee
         '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

data/lib/committee/errors.rb

@@ -10,7 +10,7 @@ module Committee
   class InvalidRequest < Error
     attr_reader :original_error
 
-    def initialize(error_message=nil, original_error: nil)
+    def initialize(error_message = nil, original_error: nil)
       @original_error = original_error
       super(error_message)
     end
@@ -19,7 +19,7 @@ module Committee
   class InvalidResponse < Error
     attr_reader :original_error
 
-    def initialize(error_message=nil, original_error: nil)
+    def initialize(error_message = nil, original_error: nil)
       @original_error = original_error
       super(error_message)
     end

data/lib/committee/middleware/base.rb

@@ -3,7 +3,7 @@
 module Committee
   module Middleware
     class Base
-      def initialize(app, options={})
+      def initialize(app, options = {})
         @app = app
 
         @error_class = options.fetch(:error_class, Committee::ValidationError)
@@ -14,7 +14,7 @@ module Committee
         @schema = self.class.get_schema(options)
 
         @router = @schema.build_router(options)
-        @accept_request_filter = options[:accept_request_filter] || -> (_) { true }
+        @accept_request_filter = options[:accept_request_filter] || ->(_) { true }
       end
 
       def call(env)

data/lib/committee/middleware/request_validation.rb

@@ -3,7 +3,7 @@
 module Committee
   module Middleware
     class RequestValidation < Base
-      def initialize(app, options={})
+      def initialize(app, options = {})
         super
 
         @strict = options[:strict]

data/lib/committee/middleware/stub.rb

@@ -5,7 +5,7 @@
 module Committee
   module Middleware
     class Stub < Base
-      def initialize(app, options={})
+      def initialize(app, options = {})
         super
 
         # A bug in Committee's cache implementation meant that it wasn't working

data/lib/committee/request_unpacker.rb

@@ -20,7 +20,7 @@ module Committee
       end
     end
 
-    def initialize(options={})
+    def initialize(options = {})
       @allow_form_params  = options[:allow_form_params]
       @allow_get_body     = options[:allow_get_body]
       @allow_query_params = options[:allow_query_params]
@@ -32,7 +32,7 @@ module Committee
       # if Content-Type is empty or JSON, and there was a request body, try to
       # interpret it as JSON
       params = if !request.media_type || request.media_type =~ %r{application/(?:.*\+)?json}
-        parse_json(request)
+                 parse_json(request)
       elsif @optimistic_json
         begin
           parse_json(request)
@@ -87,8 +87,7 @@ module Committee
       # We want a hash specifically. '42', 42, and [42] will all be
       # decoded properly, but we can't use them here.
       if !hash.is_a?(Hash)
-        raise BadRequest,
-              "Invalid JSON input. Require object with parameters as keys."
+        raise BadRequest, "Invalid JSON input. Require object with parameters as keys."
       end
       self.class.indifferent_params(hash)
     end

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

@@ -18,61 +18,61 @@ module Committee
 
         private
 
-          def coerce_object!(hash, schema)
-            return false unless schema.respond_to?(:properties)
+        def coerce_object!(hash, schema)
+          return false unless schema.respond_to?(:properties)
 
-            is_coerced = false
-            schema.properties.each do |k, s|
-              original_val = hash[k]
-              unless original_val.nil?
-                new_value, is_changed = coerce_value!(original_val, s)
-                if is_changed
-                  hash[k] = new_value
-                  is_coerced = true
-                end
+          is_coerced = false
+          schema.properties.each do |k, s|
+            original_val = hash[k]
+            unless original_val.nil?
+              new_value, is_changed = coerce_value!(original_val, s)
+              if is_changed
+                hash[k] = new_value
+                is_coerced = true
               end
             end
-
-            is_coerced
           end
 
-          def coerce_value!(original_val, s)
-            s.type.each do |to_type|
-              if @coerce_date_times && to_type == "string" && s.format == "date-time"
-                coerced_val = parse_date_time(original_val)
-                return coerced_val, true if coerced_val
-              end
-
-              return original_val, true if @coerce_recursive && (to_type == "array") && coerce_array_data!(original_val, s)
+          is_coerced
+        end
 
-              return original_val, true if @coerce_recursive && (to_type == "object") && coerce_object!(original_val, s)
+        def coerce_value!(original_val, s)
+          s.type.each do |to_type|
+            if @coerce_date_times && to_type == "string" && s.format == "date-time"
+              coerced_val = parse_date_time(original_val)
+              return coerced_val, true if coerced_val
             end
-            return nil, false
+
+            return original_val, true if @coerce_recursive && (to_type == "array") && coerce_array_data!(original_val, s)
+
+            return original_val, true if @coerce_recursive && (to_type == "object") && coerce_object!(original_val, s)
           end
+          return nil, false
+        end
 
-          def coerce_array_data!(original_val, schema)
-            return false unless schema.respond_to?(:items)
-            return false unless original_val.is_a?(Array)
+        def coerce_array_data!(original_val, schema)
+          return false unless schema.respond_to?(:items)
+          return false unless original_val.is_a?(Array)
 
-            is_coerced = false
-            original_val.each_with_index do |d, index|
-              new_value, is_changed = coerce_value!(d, schema.items)
-              if is_changed
-                original_val[index] = new_value
-                is_coerced = true
-              end
+          is_coerced = false
+          original_val.each_with_index do |d, index|
+            new_value, is_changed = coerce_value!(d, schema.items)
+            if is_changed
+              original_val[index] = new_value
+              is_coerced = true
             end
-
-            is_coerced
           end
 
-          def parse_date_time(original_val)
-            begin
-              DateTime.parse(original_val)
-            rescue ArgumentError => e
-              raise ::Committee::InvalidResponse unless e.message =~ /invalid date/
-            end
+          is_coerced
+        end
+
+        def parse_date_time(original_val)
+          begin
+            DateTime.parse(original_val)
+          rescue ArgumentError => e
+            raise ::Committee::InvalidResponse unless e.message =~ /invalid date/
           end
+        end
       end
     end
   end

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

@@ -35,8 +35,7 @@ module Committee
           content_type = ::Committee::SchemaValidator.request_media_type(request)
           if content_type && @link.enc_type && !empty_request?(request)
             unless Rack::Mime.match?(content_type, @link.enc_type)
-              raise Committee::InvalidRequest,
-                %{"Content-Type" request header must be set to "#{@link.enc_type}".}
+              raise Committee::InvalidRequest, %{"Content-Type" request header must be set to "#{@link.enc_type}".}
             end
           end
         end

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

@@ -11,7 +11,14 @@ module Committee
           @validate_success_only = options[:validate_success_only]
           @allow_blank_structures = options[:allow_blank_structures]
 
-          @validator = JsonSchema::Validator.new(target_schema(link))
+          @validators = {}
+          if link.is_a? Drivers::OpenAPI2::Link
+            link.target_schemas.each do |status, schema|
+              @validators[status] = JsonSchema::Validator.new(target_schema(link))
+            end
+          else
+            @validators[link.status_success] = JsonSchema::Validator.new(target_schema(link))
+          end
         end
 
         def call(status, headers, data)
@@ -45,9 +52,12 @@ module Committee
           end
 
           begin
-            if Committee::Middleware::ResponseValidation.validate?(status, validate_success_only) && !@validator.validate(data)
-              errors = JsonSchema::SchemaError.aggregate(@validator.errors).join("\n")
-              raise InvalidResponse, "Invalid response.\n\n#{errors}"
+            if Committee::Middleware::ResponseValidation.validate?(status, validate_success_only)
+              raise InvalidResponse, "Invalid response.#{@link.href} status code #{status} definition does not exist" if @validators[status].nil?
+              if !@validators[status].validate(data)
+                errors = JsonSchema::SchemaError.aggregate(@validators[status].errors).join("\n")
+                raise InvalidResponse, "Invalid response.\n\n#{errors}"
+              end
             end
           rescue => e
             raise InvalidResponse, "Invalid response.\n\nschema is undefined" if /undefined method .all_of. for nil/ =~ e.message
@@ -66,12 +76,10 @@ module Committee
           end
         end
 
-
         def check_content_type!(response)
           if @link.media_type
             unless Rack::Mime.match?(response_media_type(response), @link.media_type)
-              raise Committee::InvalidResponse,
-                %{"Content-Type" response header must be set to "#{@link.media_type}".}
+              raise Committee::InvalidResponse, %{"Content-Type" response header must be set to "#{@link.media_type}".}
             end
           end
         end

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

@@ -27,78 +27,78 @@ module Committee
 
         private
 
-          def coerce_object!(hash, schema)
-            return false unless schema.respond_to?(:properties)
+        def coerce_object!(hash, schema)
+          return false unless schema.respond_to?(:properties)
 
-            is_coerced = false
-            schema.properties.each do |k, s|
-              original_val = hash[k]
-              unless original_val.nil?
-                new_value, is_changed = coerce_value!(original_val, s)
-                if is_changed
-                  hash[k] = new_value
-                  is_coerced = true
-                end
+          is_coerced = false
+          schema.properties.each do |k, s|
+            original_val = hash[k]
+            unless original_val.nil?
+              new_value, is_changed = coerce_value!(original_val, s)
+              if is_changed
+                hash[k] = new_value
+                is_coerced = true
               end
             end
-
-            is_coerced
           end
 
-          def coerce_value!(original_val, s)
-            unless original_val.nil?
-              s.type.each do |to_type|
-                case to_type
-                  when "null"
-                    return nil, true if original_val.empty?
-                  when "integer"
-                    begin
-                      return Integer(original_val), true
-                    rescue ArgumentError => e
-                      raise e unless e.message =~ /invalid value for Integer/
-                    end
-                  when "number"
-                    begin
-                      return Float(original_val), true
-                    rescue ArgumentError => e
-                      raise e unless e.message =~ /invalid value for Float/
-                    end
-                  when "boolean"
-                    if original_val == "true" || original_val == "1"
-                      return true, true
-                    end
-                    if original_val == "false" || original_val == "0"
-                      return false, true
-                    end
-                  when "array"
-                    if @coerce_recursive && coerce_array_data!(original_val, s)
-                      return original_val, true # change original value
-                    end
-                  when "object"
-                    if @coerce_recursive && coerce_object!(original_val, s)
-                      return original_val, true # change original value
-                    end
-                end
+          is_coerced
+        end
+
+        def coerce_value!(original_val, s)
+          unless original_val.nil?
+            s.type.each do |to_type|
+              case to_type
+                when "null"
+                  return nil, true if original_val.empty?
+                when "integer"
+                  begin
+                    return Integer(original_val), true
+                  rescue ArgumentError => e
+                    raise e unless e.message =~ /invalid value for Integer/
+                  end
+                when "number"
+                  begin
+                    return Float(original_val), true
+                  rescue ArgumentError => e
+                    raise e unless e.message =~ /invalid value for Float/
+                  end
+                when "boolean"
+                  if original_val == "true" || original_val == "1"
+                    return true, true
+                  end
+                  if original_val == "false" || original_val == "0"
+                    return false, true
+                  end
+                when "array"
+                  if @coerce_recursive && coerce_array_data!(original_val, s)
+                    return original_val, true # change original value
+                  end
+                when "object"
+                  if @coerce_recursive && coerce_object!(original_val, s)
+                    return original_val, true # change original value
+                  end
               end
             end
-            return nil, false
           end
+          return nil, false
+        end
 
-          def coerce_array_data!(original_val, schema)
-            return false unless schema.respond_to?(:items)
-            return false unless original_val.is_a?(Array)
+        def coerce_array_data!(original_val, schema)
+          return false unless schema.respond_to?(:items)
+          return false unless original_val.is_a?(Array)
 
-            is_coerced = false
-            original_val.each_with_index do |d, index|
-              new_value, is_changed = coerce_value!(d, schema.items)
-              if is_changed
-                original_val[index] = new_value
-                is_coerced = true
-              end
+          is_coerced = false
+          original_val.each_with_index do |d, index|
+            new_value, is_changed = coerce_value!(d, schema.items)
+            if is_changed
+              original_val[index] = new_value
+              is_coerced = true
             end
-
-            is_coerced
           end
+
+          is_coerced
+        end
       end
     end
   end