committee 3.1.0 → 3.1.1

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

@@ -1,49 +1,55 @@
-module Committee
-  class SchemaValidator::HyperSchema::RequestValidator
-    def initialize(link, options = {})
-      @link = link
-      @check_content_type = options.fetch(:check_content_type, true)
-      @check_header = options.fetch(:check_header, true)
-    end
+# frozen_string_literal: true
 
-    def call(request, params, headers)
-      check_content_type!(request, params) if @check_content_type
-      if @link.schema
-        valid, errors = @link.schema.validate(params)
-        if !valid
-          errors = JsonSchema::SchemaError.aggregate(errors).join("\n")
-          raise InvalidRequest, "Invalid request.\n\n#{errors}"
+module Committee
+  module SchemaValidator
+    class HyperSchema
+      class RequestValidator
+        def initialize(link, options = {})
+          @link = link
+          @check_content_type = options.fetch(:check_content_type, true)
+          @check_header = options.fetch(:check_header, true)
         end
-      end
 
-      if @check_header && @link.respond_to?(:header_schema) && @link.header_schema
-        valid, errors = @link.header_schema.validate(headers)
-        if !valid
-          errors = JsonSchema::SchemaError.aggregate(errors).join("\n")
-          raise InvalidRequest, "Invalid request.\n\n#{errors}"
+        def call(request, params, headers)
+          check_content_type!(request, params) if @check_content_type
+          if @link.schema
+            valid, errors = @link.schema.validate(params)
+            if !valid
+              errors = JsonSchema::SchemaError.aggregate(errors).join("\n")
+              raise InvalidRequest, "Invalid request.\n\n#{errors}"
+            end
+          end
+
+          if @check_header && @link.respond_to?(:header_schema) && @link.header_schema
+            valid, errors = @link.header_schema.validate(headers)
+            if !valid
+              errors = JsonSchema::SchemaError.aggregate(errors).join("\n")
+              raise InvalidRequest, "Invalid request.\n\n#{errors}"
+            end
+          end
         end
-      end
-    end
 
-    private
+        private
 
-    def check_content_type!(request, data)
-      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}".}
+        def check_content_type!(request, data)
+          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}".}
+            end
+          end
         end
-      end
-    end
 
-    def empty_request?(request)
-      # small optimization: assume GET and DELETE don't have bodies
-      return true if request.get? || request.delete? || !request.body
+        def empty_request?(request)
+          # small optimization: assume GET and DELETE don't have bodies
+          return true if request.get? || request.delete? || !request.body
 
-      data = request.body.read
-      request.body.rewind
-      data.empty?
+          data = request.body.read
+          request.body.rewind
+          data.empty?
+        end
+      end
     end
   end
 end

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

@@ -1,95 +1,101 @@
+# frozen_string_literal: true
+
 module Committee
-  class SchemaValidator::HyperSchema::ResponseGenerator
-    def call(link)
-      schema = target_schema(link)
-      data = generate_properties(link, schema)
-
-      # List is a special case; wrap data in an array.
-      #
-      # This is poor form that's here so as not to introduce breaking behavior.
-      # The "instances" value of "rel" is a Heroku-ism and was originally
-      # introduced before we understood how to use "targetSchema". It's not
-      # meaningful with the context of the hyper-schema specification and
-      # should be eventually be removed.
-      if legacy_hyper_schema_rel?(link)
-        data = [data]
-      end
+  module SchemaValidator
+    class HyperSchema
+      class ResponseGenerator
+        def call(link)
+          schema = target_schema(link)
+          data = generate_properties(link, schema)
 
-      [data, schema]
-    end
+          # List is a special case; wrap data in an array.
+          #
+          # This is poor form that's here so as not to introduce breaking behavior.
+          # The "instances" value of "rel" is a Heroku-ism and was originally
+          # introduced before we understood how to use "targetSchema". It's not
+          # meaningful with the context of the hyper-schema specification and
+          # should be eventually be removed.
+          if legacy_hyper_schema_rel?(link)
+            data = [data]
+          end
 
-    private
-
-    # These are basic types that are part of the JSON schema for which we'll
-    # emit zero values when generating a response. For a schema that allows
-    # multiple of the types in the list, types are preferred in the order in
-    # which they're defined.
-    SCALAR_TYPES = {
-      "boolean" => false,
-      "integer" => 0,
-      "number"  => 0.0,
-      "string"  => "",
-
-      # Prefer null last.
-      "null" => nil,
-    }.freeze
-
-    def generate_properties(link, schema)
-      # special example attribute was included; use its value
-      if schema.data && !schema.data["example"].nil?
-        schema.data["example"]
-
-      elsif !schema.all_of.empty? || !schema.properties.empty?
-        data = {}
-        schema.all_of.each do |subschema|
-          data.merge!(generate_properties(link, subschema))
-        end
-        schema.properties.map do |key, value|
-          data[key] = generate_properties(link, value)
+          [data, schema]
         end
-        data
 
-      elsif schema.type.include?("array") && !schema.items.nil?
-        [generate_properties(link, schema.items)]
+        private
 
-      elsif schema.enum
-        schema.enum.first
+        # These are basic types that are part of the JSON schema for which we'll
+        # emit zero values when generating a response. For a schema that allows
+        # multiple of the types in the list, types are preferred in the order in
+        # which they're defined.
+        SCALAR_TYPES = {
+          "boolean" => false,
+          "integer" => 0,
+          "number"  => 0.0,
+          "string"  => "",
 
-      elsif schema.type.any? { |t| SCALAR_TYPES.include?(t) }
-        SCALAR_TYPES.each do |k, v|
-          break(v) if schema.type.include?(k)
-        end
+          # Prefer null last.
+          "null" => nil,
+        }.freeze
 
-      # Generate an empty array for arrays.
-      elsif schema.type == ["array"]
-        []
+        def generate_properties(link, schema)
+          # special example attribute was included; use its value
+          if schema.data && !schema.data["example"].nil?
+            schema.data["example"]
 
-      # Schema is an object with no properties: just generate an empty object.
-      elsif schema.type == ["object"]
-        {}
+          elsif !schema.all_of.empty? || !schema.properties.empty?
+            data = {}
+            schema.all_of.each do |subschema|
+              data.merge!(generate_properties(link, subschema))
+            end
+            schema.properties.map do |key, value|
+              data[key] = generate_properties(link, value)
+            end
+            data
 
-      else
-        raise(%{At "#{link.method} #{link.href}" "#{schema.pointer}": no } +
-          %{"example" attribute and "null" } +
-          %{is not allowed; don't know how to generate property.})
-      end
-    end
+          elsif schema.type.include?("array") && !schema.items.nil?
+            [generate_properties(link, schema.items)]
 
-    def legacy_hyper_schema_rel?(link)
-      link.is_a?(Committee::Drivers::HyperSchema::Link) &&
-        link.rel == "instances" &&
-        !link.target_schema
-    end
+          elsif schema.enum
+            schema.enum.first
 
-    # Gets the target schema of a link. This is normally just the standard
-    # response schema, but we allow some legacy behavior for hyper-schema links
-    # tagged with rel=instances to instead use the schema of their parent
-    # resource.
-    def target_schema(link)
-      if link.target_schema
-        link.target_schema
-      elsif legacy_hyper_schema_rel?(link)
-        link.parent
+          elsif schema.type.any? { |t| SCALAR_TYPES.include?(t) }
+            SCALAR_TYPES.each do |k, v|
+              break(v) if schema.type.include?(k)
+            end
+
+          # Generate an empty array for arrays.
+          elsif schema.type == ["array"]
+            []
+
+          # Schema is an object with no properties: just generate an empty object.
+          elsif schema.type == ["object"]
+            {}
+
+          else
+            raise(%{At "#{link.method} #{link.href}" "#{schema.pointer}": no } +
+              %{"example" attribute and "null" } +
+              %{is not allowed; don't know how to generate property.})
+          end
+        end
+
+        def legacy_hyper_schema_rel?(link)
+          link.is_a?(Committee::Drivers::HyperSchema::Link) &&
+            link.rel == "instances" &&
+            !link.target_schema
+        end
+
+        # Gets the target schema of a link. This is normally just the standard
+        # response schema, but we allow some legacy behavior for hyper-schema links
+        # tagged with rel=instances to instead use the schema of their parent
+        # resource.
+        def target_schema(link)
+          if link.target_schema
+            link.target_schema
+          elsif legacy_hyper_schema_rel?(link)
+            link.parent
+          end
+        end
       end
     end
   end

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

@@ -1,76 +1,82 @@
+# frozen_string_literal: true
+
 module Committee
-  class SchemaValidator::HyperSchema::ResponseValidator
-    attr_reader :validate_success_only
+  module SchemaValidator
+    class HyperSchema
+      class ResponseValidator
+        attr_reader :validate_success_only
 
-    def initialize(link, options = {})
-      @link = link
-      @validate_success_only = options[:validate_success_only]
+        def initialize(link, options = {})
+          @link = link
+          @validate_success_only = options[:validate_success_only]
 
-      @validator = JsonSchema::Validator.new(target_schema(link))
-    end
+          @validator = JsonSchema::Validator.new(target_schema(link))
+        end
 
-    def call(status, headers, data)
-      unless status == 204 # 204 No Content
-        response = Rack::Response.new(data, status, headers)
-        check_content_type!(response)
-      end
+        def call(status, headers, data)
+          unless status == 204 # 204 No Content
+            response = Rack::Response.new(data, status, headers)
+            check_content_type!(response)
+          end
 
-      # List is a special case; expect data in an array.
-      #
-      # This is poor form that's here so as not to introduce breaking behavior.
-      # The "instances" value of "rel" is a Heroku-ism and was originally
-      # introduced before we understood how to use "targetSchema". It's not
-      # meaningful with the context of the hyper-schema specification and
-      # should be eventually be removed.
-      if legacy_hyper_schema_rel?(@link)
-        if !data.is_a?(Array)
-          raise InvalidResponse, "List endpoints must return an array of objects."
-        end
+          # List is a special case; expect data in an array.
+          #
+          # This is poor form that's here so as not to introduce breaking behavior.
+          # The "instances" value of "rel" is a Heroku-ism and was originally
+          # introduced before we understood how to use "targetSchema". It's not
+          # meaningful with the context of the hyper-schema specification and
+          # should be eventually be removed.
+          if legacy_hyper_schema_rel?(@link)
+            if !data.is_a?(Array)
+              raise InvalidResponse, "List endpoints must return an array of objects."
+            end
 
-        # only consider the first object during the validation from here on
-        # (but only in cases where `targetSchema` is not set)
-        data = data[0]
+            # only consider the first object during the validation from here on
+            # (but only in cases where `targetSchema` is not set)
+            data = data[0]
 
-        # if the array was empty, allow it through
-        return if data == nil
-      end
+            # if the array was empty, allow it through
+            return if data == nil
+          end
 
-      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}"
-      end
-    end
+          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}"
+          end
+        end
 
-    private
+        private
 
-    def response_media_type(response)
-      response.content_type.to_s.split(";").first.to_s
-    end
+        def response_media_type(response)
+          response.content_type.to_s.split(";").first.to_s
+        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}".}
+        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}".}
+            end
+          end
         end
-      end
-    end
 
-    def legacy_hyper_schema_rel?(link)
-      link.is_a?(Committee::Drivers::HyperSchema::Link) &&
-        link.rel == "instances" &&
-        !link.target_schema
-    end
+        def legacy_hyper_schema_rel?(link)
+          link.is_a?(Committee::Drivers::HyperSchema::Link) &&
+            link.rel == "instances" &&
+            !link.target_schema
+        end
 
-    # Gets the target schema of a link. This is normally just the standard
-    # response schema, but we allow some legacy behavior for hyper-schema links
-    # tagged with rel=instances to instead use the schema of their parent
-    # resource.
-    def target_schema(link)
-      if link.target_schema
-        link.target_schema
-      elsif legacy_hyper_schema_rel?(link)
-        link.parent
+        # Gets the target schema of a link. This is normally just the standard
+        # response schema, but we allow some legacy behavior for hyper-schema links
+        # tagged with rel=instances to instead use the schema of their parent
+        # resource.
+        def target_schema(link)
+          if link.target_schema
+            link.target_schema
+          elsif legacy_hyper_schema_rel?(link)
+            link.parent
+          end
+        end
       end
     end
   end

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

@@ -1,40 +1,46 @@
+# frozen_string_literal: true
+
 module Committee
-  class SchemaValidator::HyperSchema::Router
-    def initialize(schema, validator_option)
-      @prefix = validator_option.prefix
-      @prefix_regexp = /\A#{Regexp.escape(@prefix)}/.freeze if @prefix
-      @schema = schema
+  module SchemaValidator
+    class HyperSchema
+      class Router
+        def initialize(schema, validator_option)
+          @prefix = validator_option.prefix
+          @prefix_regexp = /\A#{Regexp.escape(@prefix)}/.freeze if @prefix
+          @schema = schema
 
-      @validator_option = validator_option
-    end
+          @validator_option = validator_option
+        end
 
-    def includes?(path)
-      !@prefix || path =~ @prefix_regexp
-    end
+        def includes?(path)
+          !@prefix || path =~ @prefix_regexp
+        end
 
-    def includes_request?(request)
-      includes?(request.path)
-    end
+        def includes_request?(request)
+          includes?(request.path)
+        end
 
-    def find_link(method, path)
-      path = path.gsub(@prefix_regexp, "") if @prefix
-      link_with_matches = (@schema.routes[method] || []).map do |pattern, link|
-        if matches = pattern.match(path)
-          # prefer path which has fewer matches (eg. `/pets/dog` than `/pets/{uuid}` for path `/pets/dog` )
-          [matches.captures.size, link, Hash[matches.names.zip(matches.captures)]]
-        else
-          nil
+        def find_link(method, path)
+          path = path.gsub(@prefix_regexp, "") if @prefix
+          link_with_matches = (@schema.routes[method] || []).map do |pattern, link|
+            if matches = pattern.match(path)
+              # prefer path which has fewer matches (eg. `/pets/dog` than `/pets/{uuid}` for path `/pets/dog` )
+              [matches.captures.size, link, Hash[matches.names.zip(matches.captures)]]
+            else
+              nil
+            end
+          end.compact.sort_by(&:first).first
+          link_with_matches.nil? ? nil : link_with_matches.slice(1, 2)
         end
-      end.compact.sort_by(&:first).first
-      link_with_matches.nil? ? nil : link_with_matches.slice(1, 2)
-    end
 
-    def find_request_link(request)
-      find_link(request.request_method, request.path_info)
-    end
+        def find_request_link(request)
+          find_link(request.request_method, request.path_info)
+        end
 
-    def build_schema_validator(request)
-      Committee::SchemaValidator::HyperSchema.new(self, request, @validator_option)
+        def build_schema_validator(request)
+          Committee::SchemaValidator::HyperSchema.new(self, request, @validator_option)
+        end
+      end
     end
   end
 end