jsapi 2.1.2 → 3.0

data/lib/jsapi/{meta → definition}/model/reference.rb

@@ -1,14 +1,14 @@
 # frozen_string_literal: true
 
 module Jsapi
-  module Meta
+  module Definition
     module Model
       # The base reference class.
       class Reference < Base
         class Resolver # :nodoc:
-          def initialize(reference, definitions)
+          def initialize(reference, api)
             @reference = reference
-            @definitions = definitions
+            @api = api
           end
 
           protected
@@ -24,8 +24,8 @@ module Jsapi
             return result unless result.nil?
 
             @reference
-              .resolve(@definitions, deep: false)
-              .resolve_lazily(@definitions)
+              .resolve(@api, deep: false)
+              .resolve_lazily(@api)
               .send(name, ...)
           end
         end
@@ -66,21 +66,21 @@ module Jsapi
           true
         end
 
-        # Resolves the reference by looking up the referred object in +definitions+.
+        # Resolves the reference by looking up the referred object in +api+.
         #
         # Raises a ReferenceError if the reference could not be resolved.
-        def resolve(definitions, deep: true)
-          object = definitions.send("find_#{self.class.component_type}", ref)
+        def resolve(api, deep: true)
+          object = api.send("find_#{self.class.component_type}", ref)
           raise ReferenceError, ref if object.nil?
 
-          deep ? object.resolve(definitions, deep: true) : object
+          deep ? object.resolve(api, deep: true) : object
         end
 
         # Lazily resolves the reference.
         #
         # Raises a ReferenceError if the reference could not be resolved.
-        def resolve_lazily(definitions)
-          Resolver.new(self, definitions)
+        def resolve_lazily(api)
+          Resolver.new(self, api)
         end
 
         # Returns a hash representing the \OpenAPI reference object.

data/lib/jsapi/{meta → definition}/model/wrappable.rb

@@ -1,19 +1,19 @@
 # frozen_string_literal: true
 
 module Jsapi
-  module Meta
+  module Definition
     module Model
       # Defines a +wrap+ class method to wrap an instance of the given class.
       module Wrappable
         def self.included(base) # :nodoc:
           class << base
-            define_method(:wrap) do |model, definitions|
+            define_method(:wrap) do |model, api|
               return if model.nil?
 
               wrapper_class = "#{name}::Wrapper".constantize
               return model if model.is_a?(wrapper_class)
 
-              wrapper_class.new(model, definitions)
+              wrapper_class.new(model, api)
             end
           end
         end

data/lib/jsapi/{meta → definition}/model/wrapper.rb

@@ -1,15 +1,15 @@
 # frozen_string_literal: true
 
 module Jsapi
-  module Meta
+  module Definition
     module Model
       # Wraps a meta model
       class Wrapper < SimpleDelegator
-        attr_reader :definitions
+        attr_reader :api
 
-        def initialize(model, definitions)
-          super(model.resolve(definitions))
-          @definitions = definitions
+        def initialize(model, api)
+          super(model.resolve(api))
+          @api = api
         end
 
         def ==(other) # :nodoc:

data/lib/jsapi/{meta → definition}/oauth_flow.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Jsapi
-  module Meta
+  module Definition
     # Represents an OAuth flow object.
     class OAuthFlow < Model::Base
       include OpenAPI::Extensions

data/lib/jsapi/{meta → definition}/openapi/extensions.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Jsapi
-  module Meta
+  module Definition
     module OpenAPI
       module Extensions
         def self.included(base) # :nodoc:

data/lib/jsapi/{meta → definition}/openapi/path_item.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Jsapi
-  module Meta
+  module Definition
     module OpenAPI
       class PathItem # :nodoc:
         def initialize(operations, keywords = {})
@@ -12,7 +12,7 @@ module Jsapi
           @parameters = keywords[:parameters]
         end
 
-        def to_openapi(version, definitions)
+        def to_openapi(version, api)
           version = OpenAPI::Version.from(version)
 
           {}.tap do |fields|
@@ -27,10 +27,10 @@ module Jsapi
               standardized_method = method.downcase
 
               if standard_method?(standardized_method, version)
-                fields[standardized_method] = operation.to_openapi(version, definitions)
+                fields[standardized_method] = operation.to_openapi(version, api)
               elsif version >= OpenAPI::V3_2
                 additional_operations = fields[:additionalOperations] ||= {}
-                additional_operations[method] = operation.to_openapi(version, definitions)
+                additional_operations[method] = operation.to_openapi(version, api)
               end
             end
 
@@ -42,7 +42,7 @@ module Jsapi
             # Parameters
             if @parameters.present?
               fields[:parameters] = @parameters.values.map do |parameter|
-                parameter.to_openapi(version, definitions)
+                parameter.to_openapi(version, api)
               end
             end
           end

data/lib/jsapi/{meta → definition}/openapi/version.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Jsapi
-  module Meta
+  module Definition
     module OpenAPI
       class Version
         include Comparable
@@ -60,7 +60,7 @@ module Jsapi
             when [3, 1]
               '3.1.2'
             when [3, 2]
-              '3.2.0'
+              '3.2.1'
             else
               "#{major}.#{minor}"
             end

data/lib/jsapi/{meta → definition}/openapi.rb

@@ -5,7 +5,7 @@ require_relative 'openapi/version'
 require_relative 'openapi/path_item'
 
 module Jsapi
-  module Meta
+  module Definition
     module OpenAPI
       V2_0 = Version.new(2, 0)
       V3_0 = Version.new(3, 0)

data/lib/jsapi/{meta → definition}/operation.rb

@@ -1,14 +1,54 @@
 # frozen_string_literal: true
 
 module Jsapi
-  module Meta
+  module Definition
+    # Raised when no response matches +status+.
+    class ResponseNotFound < StandardError
+      def initialize(operation, status)
+        super(
+          if operation.responses.none?
+            "#{operation.name.inspect} has no responses"
+          else
+            "#{operation.name.inspect} has no response for status #{status}"
+          end
+        )
+      end
+    end
+
     # Specifies an API operation.
     class Operation < Model::Base
       include OpenAPI::Extensions
 
       class Wrapper < Model::Wrapper
-        # Returns the most appropriate response for +status_code+.
-        def find_response(status_code)
+        ##
+        # :attr_reader: model
+        # The model class of the wrapped operation or the default model class
+        # for the path.
+
+        ##
+        # :attr_reader: parameters
+        # The parameters of the wrapped operation in combination with the
+        # parameters applying to all operations in the path.
+
+        ##
+        # :attr_reader: request_body
+        # The request body of the wrapped operation or the default request
+        # body for the path.
+
+        ##
+        # :attr_reader: responses
+        # The responses of the wrapped operation in combination with the
+        # responses applying to all operations in the path.
+
+        ##
+        # :attr_reader: security_requirements
+        # The security requirements of the wrapped operation in combination
+        # with the security requirements applying to all operations in the
+        # path or the default security requirements.
+
+        # Returns the most appropriate response for +status_code+ or +nil+ if no
+        # response matches.
+        def find_response_for(status_code)
           status_code = Status::Code.from(status_code)
 
           responses.find do |status, _response|
@@ -16,77 +56,78 @@ module Jsapi
           end&.second
         end
 
+        # Like +find_response_for+, except that it raises a ResponseNotFound
+        # error when no response matches.
+        def find_response_for!(status_code)
+          response = find_response_for(status_code)
+          return response if response
+
+          raise ResponseNotFound.new(self, status_code)
+        end
+
         def full_path # :nodoc:
           @full_path ||= super
         end
 
-        ##
-        # :attr_reader: model
-        # The model class of the wrapped operation or the default model class
-        # for the path.
+        # Returns a hash containing all +header+ parameters.
+        def header_parameters
+          @header_parameters ||= parameters.select do |_name, parameter|
+            parameter.in == 'header'
+          end
+        end
 
-        # -
-        def model
+        def model # :nodoc:
           return @model if defined? @model
 
-          @model = super || definitions.common_model(full_path)
+          @model = super || api.common_model(full_path)
         end
 
-        ##
-        # :attr_reader: parameters
-        # The parameters of the wrapped operation in combination with the
-        # parameters applying to all operations in the path.
-
-        # -
-        def parameters
+        def parameters # :nodoc:
           @parameters ||=
-            (definitions.common_parameters(full_path)&.merge(super) || super)
-            .transform_values { |parameter| Parameter.wrap(parameter, definitions) }
+            (api.common_parameters(full_path)&.merge(super) || super)
+            .transform_values { |parameter| Parameter.wrap(parameter, api) }
         end
 
-        ##
-        # :attr_reader: request_body
-        # The request body of the wrapped operation or the default request
-        # body for the path.
+        # Returns a hash containing all +query+ parameters.
+        def query_parameters
+          @query_parameters ||= parameters.select do |_name, parameter|
+            parameter.in == 'query'
+          end
+        end
 
-        # -
-        def request_body
+        # Returns the sole +querystring+ parameter if present, otherwise +nil+.
+        def querystring_parameter
+          return @querystring_parameter if defined? @querystring_parameter
+
+          @querystring_parameter = parameters.each_value.find do |parameter|
+            parameter.in == 'querystring'
+          end
+        end
+
+        def request_body # :nodoc:
           return @request_body if defined? @request_body
 
           @request_body = RequestBody.wrap(
-            (super || definitions.common_request_body(full_path)),
-            definitions
+            super || api.common_request_body(full_path),
+            api
           )
         end
 
-        ##
-        # :attr_reader: responses
-        # The responses of the wrapped operation in combination with the
-        # responses applying to all operations in the path.
-
-        # -
-        def responses
+        def responses # :nodoc:
           @responses ||=
-            (definitions.common_responses(full_path)&.merge(super) || super)
-            .transform_values { |response| Response.wrap(response, definitions) }
+            (api.common_responses(full_path)&.merge(super) || super)
+            .transform_values { |response| Response.wrap(response, api) }
             .sort_by { |status, _response| status }
             .to_h
         end
 
-        ##
-        # :attr_reader: security_requirements
-        # The security requirements of the wrapped operation in combination
-        # with the security requirements applying to all operations in the
-        # path or the default security requirements.
-
-        # -
-        def security_requirements
+        def security_requirements # :nodoc:
           return @security_requirements if defined? @security_requirements
 
           @security_requirements =
-            [definitions.common_security_requirements(full_path), super]
-              .compact.presence&.flatten ||
-              definitions.default_security_requirements
+            [api.common_security_requirements(full_path), super]
+            .compact.presence&.flatten ||
+            api.default_security_requirements
         end
       end
 
@@ -118,8 +159,13 @@ module Jsapi
       ##
       # :attr: method
       # The HTTP method of the operation, <code>"get"</code> by default.
+      #
+      # Aliased as +http_method+.
       attribute :method, String, default: 'get'
 
+      alias http_method method # :nodoc:
+      alias http_method= method= # :nodoc:
+
       ##
       # :attr: model
       # The model class to access top-level parameters by.
@@ -220,43 +266,43 @@ module Jsapi
       end
 
       # Returns a hash representing the \OpenAPI operation object.
-      def to_openapi(version, definitions)
+      def to_openapi(version, api)
         version = OpenAPI::Version.from(version)
         full_path = self.full_path
 
         responses = (
-          definitions.common_responses(full_path)&.merge(self.responses) ||
+          api.common_responses(full_path)&.merge(self.responses) ||
           self.responses
         ).reject do |status, response|
-          response.resolve_lazily(definitions).nodoc ||
+          response.resolve_lazily(api).nodoc ||
             version == OpenAPI::V2_0 && status.is_a?(Status::Range)
         end
 
         with_openapi_extensions(
           operationId: name,
           tags:
-            [tags, definitions.common_tags(full_path)]
-              .compact.flatten.uniq.presence,
+            [tags, api.common_tags(full_path)]
+            .compact.flatten.uniq.presence,
           summary: summary,
           description: description,
           externalDocs: external_docs&.to_openapi,
           **if version == OpenAPI::V2_0
               resolved_request_body =
-                (request_body || definitions.common_request_body(full_path))
-                &.resolve(definitions)
+                (request_body || api.common_request_body(full_path))
+                &.resolve(api)
               {
                 consumes:
                   [resolved_request_body&.default_media_range]
-                    .compact.presence,
+                  .compact.presence,
                 produces:
                   responses.values.filter_map do |response|
-                    response.resolve(definitions).default_media_type
+                    response.resolve(api).default_media_type
                   end.uniq.sort.presence,
                 schemes: schemes.presence,
                 parameters:
                   begin
                     params = parameters.values.flat_map do |parameter|
-                      parameter.to_openapi_parameters(version, definitions)
+                      parameter.to_openapi_parameters(version, api)
                     end
                     if resolved_request_body
                       params << resolved_request_body.to_openapi_parameter
@@ -272,23 +318,23 @@ module Jsapi
                   end.presence,
                 callbacks:
                   callbacks.transform_values do |callback|
-                    callback.to_openapi(version, definitions)
+                    callback.to_openapi(version, api)
                   end.presence,
                 parameters:
                   parameters.values.flat_map do |parameter|
-                    parameter.to_openapi_parameters(version, definitions)
+                    parameter.to_openapi_parameters(version, api)
                   end,
                 requestBody: request_body&.to_openapi(version)
               }
             end,
           responses:
             responses.transform_values do |response|
-              response.to_openapi(version, definitions)
+              response.to_openapi(version, api)
             end,
           deprecated: deprecated?.presence,
           security:
-            [security_requirements, definitions.common_security_requirements(full_path)]
-              .compact.presence&.flatten&.map(&:to_openapi)
+            [security_requirements, api.common_security_requirements(full_path)]
+            .compact.presence&.flatten&.map(&:to_openapi)
         )
       end
     end

data/lib/jsapi/{meta → definition}/parameter/base.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Jsapi
-  module Meta
+  module Definition
     module Parameter
       # Specifies a parameter.
       class Base < Model::Base
@@ -87,12 +87,12 @@ module Jsapi
         end
 
         # Returns a hash representing the \OpenAPI parameter object.
-        def to_openapi(version, definitions)
+        def to_openapi(version, api)
           version = OpenAPI::Version.from(version)
 
           openapi_parameter_object(
             name,
-            schema.resolve(definitions),
+            schema.resolve(api),
             version,
             location: self.in,
             content_type: content_type ||
@@ -106,31 +106,31 @@ module Jsapi
         end
 
         # Returns an array of hashes representing the \OpenAPI parameter objects.
-        def to_openapi_parameters(version, definitions)
+        def to_openapi_parameters(version, api)
           version = OpenAPI::Version.from(version)
           is_querystring = self.in == 'querystring'
-          schema = self.schema.resolve(definitions)
+          schema = self.schema.resolve(api)
 
           if schema.object? && (version < OpenAPI::V3_2 || !is_querystring)
             explode_parameter(
               is_querystring ? nil : name,
               schema,
               version,
-              definitions,
+              api,
               location: is_querystring ? 'query' : self.in,
               required: required?,
               deprecated: deprecated?
             )
           else
-            [to_openapi(version, definitions)]
+            [to_openapi(version, api)]
           end.compact
         end
 
         private
 
-        def explode_parameter(name, schema, version, definitions, location:, required:, deprecated:)
-          schema.resolve_properties(definitions, context: :request).values.flat_map do |property|
-            property_schema = property.schema.resolve(definitions)
+        def explode_parameter(name, schema, version, api, location:, required:, deprecated:)
+          schema.resolve_properties(api, context: :request).values.flat_map do |property|
+            property_schema = property.schema.resolve(api)
             parameter_name = name ? "#{name}[#{property.name}]" : property.name
             required = (required && property.required?).presence
             deprecated = (deprecated || property_schema.deprecated?).presence
@@ -140,7 +140,7 @@ module Jsapi
                 parameter_name,
                 property_schema,
                 version,
-                definitions,
+                api,
                 location: location,
                 required: required,
                 deprecated: deprecated

data/lib/jsapi/{meta → definition}/parameter/reference.rb

@@ -1,20 +1,20 @@
 # frozen_string_literal: true
 
 module Jsapi
-  module Meta
+  module Definition
     module Parameter
       # Refers a reusable parameter.
       class Reference < Model::Reference
         # Returns an array of hashes representing the \OpenAPI parameter or reference objects.
         #
         # Raises a ReferenceError when the reference could not be resolved.
-        def to_openapi_parameters(version, definitions)
+        def to_openapi_parameters(version, api)
           version = OpenAPI::Version.from(version)
-          parameter = resolve(definitions)
+          parameter = resolve(api)
 
-          if parameter.schema.resolve(definitions).object?
+          if parameter.schema.resolve(api).object?
             # Explode referred parameter
-            parameter.to_openapi_parameters(version, definitions)
+            parameter.to_openapi_parameters(version, api)
           else
             # Return an array containing the reference object
             [to_openapi(version)]

data/lib/jsapi/{meta → definition}/parameter/wrapper.rb

@@ -1,11 +1,11 @@
 # frozen_string_literal: true
 
 module Jsapi
-  module Meta
+  module Definition
     module Parameter
       class Wrapper < Model::Wrapper
         def schema
-          @schema ||= Schema.wrap(super, definitions)
+          @schema ||= Schema.wrap(super, api)
         end
       end
     end

data/lib/jsapi/{meta → definition}/parameter.rb

@@ -5,7 +5,7 @@ require_relative 'parameter/reference'
 require_relative 'parameter/wrapper'
 
 module Jsapi
-  module Meta
+  module Definition
     module Parameter
       include Model::Wrappable
 

data/lib/jsapi/{meta → definition}/path.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Jsapi
-  module Meta
+  module Definition
     # Specifies a path.
     class Path < Model::Base
       ##

data/lib/jsapi/{meta → definition}/pathname.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Jsapi
-  module Meta
+  module Definition
     # Represents a relative path name.
     class Pathname
       class << self

data/lib/jsapi/{meta → definition}/property.rb

@@ -1,14 +1,14 @@
 # frozen_string_literal: true
 
 module Jsapi
-  module Meta
+  module Definition
     # Specifies a property
     class Property < Model::Base
       class Wrapper < Model::Wrapper
         delegate :additional_properties, :default_value, :items, to: :schema
 
         def schema
-          @schema ||= Schema.wrap(super, definitions)
+          @schema ||= Schema.wrap(super, api)
         end
       end
 

data/lib/jsapi/{meta → definition}/reference_error.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Jsapi
-  module Meta
+  module Definition
     # Raised when a reference can't be resolved.
     class ReferenceError < StandardError
       def initialize(reference)

data/lib/jsapi/{meta → definition}/request_body/base.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Jsapi
-  module Meta
+  module Definition
     module RequestBody
       # Specifies a request body.
       class Base < Model::Base

data/lib/jsapi/{meta → definition}/request_body/reference.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Jsapi
-  module Meta
+  module Definition
     module RequestBody
       # Refers a reusable request body.
       class Reference < Model::Reference; end

data/lib/jsapi/{meta → definition}/request_body/wrapper.rb

@@ -1,11 +1,11 @@
 # frozen_string_literal: true
 
 module Jsapi
-  module Meta
+  module Definition
     module RequestBody
       class Wrapper < Model::Wrapper
         def content_for(media_type)
-          Content.wrap(super, definitions)
+          Content.wrap(super, api)
         end
       end
     end