committee 3.1.0 → 3.1.1

data/lib/committee/middleware/stub.rb

@@ -1,70 +1,74 @@
+# frozen_string_literal: true
+
 # Stub is not yet supported in OpenAPI 3
 
-module Committee::Middleware
-  class Stub < Base
-    def initialize(app, options={})
-      super
+module Committee
+  module Middleware
+    class Stub < Base
+      def initialize(app, options={})
+        super
 
-      # A bug in Committee's cache implementation meant that it wasn't working
-      # for a very long time, even for people who thought they were taking
-      # advantage of it. I repaired the caching feature, but have disable it by
-      # default so that we don't need to introduce any class-level variables
-      # that could have memory leaking implications. To enable caching, just
-      # pass an empty hash to this option.
-      @cache = options[:cache]
+        # A bug in Committee's cache implementation meant that it wasn't working
+        # for a very long time, even for people who thought they were taking
+        # advantage of it. I repaired the caching feature, but have disable it by
+        # default so that we don't need to introduce any class-level variables
+        # that could have memory leaking implications. To enable caching, just
+        # pass an empty hash to this option.
+        @cache = options[:cache]
 
-      @call = options[:call]
+        @call = options[:call]
 
-      raise Committee::OpenAPI3Unsupported.new("Stubs are not yet supported for OpenAPI 3") unless @schema.supports_stub?
-    end
+        raise Committee::OpenAPI3Unsupported.new("Stubs are not yet supported for OpenAPI 3") unless @schema.supports_stub?
+      end
 
-    def handle(request)
-      link, _ = @router.find_request_link(request)
-      if link
-        headers = { "Content-Type" => "application/json" }
+      def handle(request)
+        link, _ = @router.find_request_link(request)
+        if link
+          headers = { "Content-Type" => "application/json" }
 
-        data, schema = cache(link) do
-          Committee::SchemaValidator::HyperSchema::ResponseGenerator.new.call(link)
-        end
+          data, schema = cache(link) do
+            Committee::SchemaValidator::HyperSchema::ResponseGenerator.new.call(link)
+          end
 
-        if @call
-          request.env["committee.response"] = data
-          request.env["committee.response_schema"] = schema
-          call_status, call_headers, call_body = @app.call(request.env)
+          if @call
+            request.env["committee.response"] = data
+            request.env["committee.response_schema"] = schema
+            call_status, call_headers, call_body = @app.call(request.env)
 
-          # a committee.suppress signal initiates a direct pass through
-          if request.env["committee.suppress"] == true
-            return call_status, call_headers, call_body
-          end
+            # a committee.suppress signal initiates a direct pass through
+            if request.env["committee.suppress"] == true
+              return call_status, call_headers, call_body
+            end
 
-          # otherwise keep the headers and whatever data manipulations were
-          # made, and stub normally
-          headers.merge!(call_headers)
+            # otherwise keep the headers and whatever data manipulations were
+            # made, and stub normally
+            headers.merge!(call_headers)
 
-          # allow the handler to change the data object (if unchanged, it
-          # will be the same one that we set above)
-          data = request.env["committee.response"]
-        end
+            # allow the handler to change the data object (if unchanged, it
+            # will be the same one that we set above)
+            data = request.env["committee.response"]
+          end
 
-        [link.status_success, headers, [JSON.pretty_generate(data)]]
-      else
-        @app.call(request.env)
+          [link.status_success, headers, [JSON.pretty_generate(data)]]
+        else
+          @app.call(request.env)
+        end
       end
-    end
 
-    private
+      private
 
-    def cache(link)
-      return yield unless @cache
+      def cache(link)
+        return yield unless @cache
 
-      # Just the object ID is enough to uniquely identify the link, but store
-      # the method and href so that we can more easily introspect the cache if
-      # necessary.
-      key = "#{link.object_id}##{link.method}+#{link.href}"
-      if @cache[key]
-        @cache[key]
-      else
-        @cache[key] = yield
+        # Just the object ID is enough to uniquely identify the link, but store
+        # the method and href so that we can more easily introspect the cache if
+        # necessary.
+        key = "#{link.object_id}##{link.method}+#{link.href}"
+        if @cache[key]
+          @cache[key]
+        else
+          @cache[key] = yield
+        end
       end
     end
   end

data/lib/committee/request_unpacker.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Committee
   class RequestUnpacker
     def initialize(request, options={})
@@ -96,7 +98,7 @@ module Committee
         headers
       end
 
-      base.merge!('Content-Type' => env['CONTENT_TYPE']) if env['CONTENT_TYPE']
+      base['Content-Type'] = env['CONTENT_TYPE'] if env['CONTENT_TYPE']
       base
     end
   end

data/lib/committee/schema_validator.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Committee
+  module SchemaValidator
+    class << self
+      def request_media_type(request)
+        request.content_type.to_s.split(";").first.to_s
+      end
+
+      # @param [String] prefix
+      # @return [Regexp]
+      def build_prefix_regexp(prefix)
+        return nil unless prefix
+
+        /\A#{Regexp.escape(prefix)}/.freeze
+      end
+    end
+  end
+end
+
+require_relative "schema_validator/hyper_schema"
+require_relative "schema_validator/open_api_3"
+require_relative "schema_validator/option"

data/lib/committee/schema_validator/hyper_schema.rb

@@ -1,94 +1,105 @@
-class Committee::SchemaValidator
-  class HyperSchema
-    attr_reader :link, :param_matches, :validator_option
+# frozen_string_literal: true
 
-    def initialize(router, request, validator_option)
-      @link, @param_matches = router.find_request_link(request)
-      @validator_option = validator_option
-    end
-
-    def request_validate(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
-
-      request_unpack(request)
-
-      request.env[validator_option.params_key].merge!(param_matches_hash) if param_matches_hash
-
-      request_schema_validation(request)
-      parameter_coerce!(request, link, validator_option.params_key)
-      parameter_coerce!(request, link, "rack.request.query_hash") if link_exist? && !request.GET.nil? && !link.schema.nil?
-    end
-
-    def response_validate(status, headers, response, _test_method = false)
-      return unless link_exist?
+module Committee
+  module SchemaValidator
+    class HyperSchema
+      attr_reader :link, :param_matches, :validator_option
 
-      full_body = ""
-      response.each do |chunk|
-        full_body << chunk
+      def initialize(router, request, validator_option)
+        @link, @param_matches = router.find_request_link(request)
+        @validator_option = validator_option
       end
-      data = full_body.empty? ? {} : JSON.parse(full_body)
-      Committee::SchemaValidator::HyperSchema::ResponseValidator.new(link, validate_success_only: validator_option.validate_success_only).call(status, headers, data)
-    end
 
-    def link_exist?
-      !link.nil?
-    end
+      def request_validate(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 : {}
 
-    def coerce_form_params(parameter)
-      return unless link_exist?
-      return unless link.schema
-      Committee::SchemaValidator::HyperSchema::StringParamsCoercer.new(parameter, link.schema).call!
-    end
+        # 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
 
-    private
+        request_unpack(request)
 
-      def coerce_path_params
-        return unless link_exist?
+        request.env[validator_option.params_key].merge!(param_matches_hash) if param_matches_hash
 
-        Committee::SchemaValidator::HyperSchema::StringParamsCoercer.new(param_matches, link.schema, coerce_recursive: validator_option.coerce_recursive).call!
-        param_matches
+        request_schema_validation(request)
+        parameter_coerce!(request, link, validator_option.params_key)
+        parameter_coerce!(request, link, "rack.request.query_hash") if link_exist? && !request.GET.nil? && !link.schema.nil?
       end
 
-      def coerce_query_params(request)
+      def response_validate(status, headers, response, _test_method = false)
         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!
+        full_body = +""
+        response.each do |chunk|
+          full_body << chunk
+        end
+        data = full_body.empty? ? {} : JSON.parse(full_body)
+        Committee::SchemaValidator::HyperSchema::ResponseValidator.new(link, validate_success_only: validator_option.validate_success_only).call(status, headers, data)
       end
 
-      def request_unpack(request)
-        request.env[validator_option.params_key], request.env[validator_option.headers_key] = Committee::RequestUnpacker.new(
-            request,
-            allow_form_params:  validator_option.allow_form_params,
-            allow_get_body:     validator_option.allow_get_body,
-            allow_query_params: validator_option.allow_query_params,
-            coerce_form_params: validator_option.coerce_form_params,
-            optimistic_json:    validator_option.optimistic_json,
-            schema_validator:   self
-        ).call
+      def link_exist?
+        !link.nil?
       end
 
-      def request_schema_validation(request)
+      def coerce_form_params(parameter)
         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])
+        return unless link.schema
+        Committee::SchemaValidator::HyperSchema::StringParamsCoercer.new(parameter, link.schema).call!
       end
 
-      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
+      private
+
+        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
+
+        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
+
+        def request_unpack(request)
+          request.env[validator_option.params_key], request.env[validator_option.headers_key] = Committee::RequestUnpacker.new(
+              request,
+              allow_form_params:  validator_option.allow_form_params,
+              allow_get_body:     validator_option.allow_get_body,
+              allow_query_params: validator_option.allow_query_params,
+              coerce_form_params: validator_option.coerce_form_params,
+              optimistic_json:    validator_option.optimistic_json,
+              schema_validator:   self
+          ).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 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
+    end
   end
-end
+end
+
+require_relative "hyper_schema/request_validator"
+require_relative "hyper_schema/response_generator"
+require_relative "hyper_schema/response_validator"
+require_relative "hyper_schema/router"
+require_relative "hyper_schema/string_params_coercer"
+require_relative "hyper_schema/parameter_coercer"

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

@@ -1,73 +1,79 @@
+# frozen_string_literal: true
+
 module Committee
-  class SchemaValidator::HyperSchema::ParameterCoercer
-    def initialize(params, schema, options = {})
-      @params = params
-      @schema = schema
+  module SchemaValidator
+    class HyperSchema
+      class ParameterCoercer
+        def initialize(params, schema, options = {})
+          @params = params
+          @schema = schema
 
-      @coerce_date_times = options.fetch(:coerce_date_times, false)
-      @coerce_recursive = options.fetch(:coerce_recursive, false)
-    end
+          @coerce_date_times = options.fetch(:coerce_date_times, false)
+          @coerce_recursive = options.fetch(:coerce_recursive, false)
+        end
 
-    def call!
-      coerce_object!(@params, @schema)
-    end
+        def call!
+          coerce_object!(@params, @schema)
+        end
 
-    private
+        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
+            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
             end
+
+            is_coerced
           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)
 
-      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
+              return original_val, true if @coerce_recursive && (to_type == "object") && coerce_object!(original_val, s)
+            end
+            return nil, false
           end
 
-          return original_val, true if @coerce_recursive && (to_type == "array") && coerce_array_data!(original_val, s)
+          def coerce_array_data!(original_val, schema)
+            return false unless schema.respond_to?(:items)
+            return false unless original_val.is_a?(Array)
 
-          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)
+            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
+            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
+            is_coerced
           end
-        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
+          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
 end