jsapi 1.4 → 2.0

data/lib/jsapi/meta/schema/numeric.rb

@@ -21,34 +21,40 @@ module Jsapi
         attribute :multiple_of, accessors: %i[reader]
 
         def maximum=(value) # :nodoc:
-          boundary = Boundary.from(value)
-
-          add_validation(
-            'maximum',
-            Validation::Maximum.new(
-              boundary.value,
-              exclusive: boundary.exclusive?
+          try_modify_attribute!(:maximum) do
+            boundary = Boundary.from(value)
+
+            add_validation(
+              'maximum',
+              Validation::Maximum.new(
+                boundary.value,
+                exclusive: boundary.exclusive?
+              )
             )
-          )
-          @maximum = boundary
+            @maximum = boundary
+          end
         end
 
         def minimum=(value) # :nodoc:
-          boundary = Boundary.from(value)
-
-          add_validation(
-            'minimum',
-            Validation::Minimum.new(
-              boundary.value,
-              exclusive: boundary.exclusive?
+          try_modify_attribute!(:minimum) do
+            boundary = Boundary.from(value)
+
+            add_validation(
+              'minimum',
+              Validation::Minimum.new(
+                boundary.value,
+                exclusive: boundary.exclusive?
+              )
             )
-          )
-          @minimum = boundary
+            @minimum = boundary
+          end
         end
 
         def multiple_of=(value) # :nodoc:
-          add_validation('multiple_of', Validation::MultipleOf.new(value))
-          @multiple_of = value
+          try_modify_attribute!(:multiple_of) do
+            add_validation('multiple_of', Validation::MultipleOf.new(value))
+            @multiple_of = value
+          end
         end
       end
     end

data/lib/jsapi/meta/schema/object.rb

@@ -4,6 +4,62 @@ module Jsapi
   module Meta
     module Schema
       class Object < Base
+        class Wrapper < Schema::Wrapper
+          def additional_properties
+            AdditionalProperties.wrap(super, definitions)
+          end
+
+          def resolve_properties(context: nil)
+            super(definitions, context: context).transform_values do |property|
+              Property.wrap(property, definitions)
+            end
+          end
+
+          # Resolves the schema within +context+.
+          #
+          # Raises a +RuntimeError+ when the schema couldn't be resolved.
+          def resolve_schema(object, context: nil)
+            return self if discriminator.nil?
+
+            properties = resolve_properties(context: context)
+
+            discriminating_property = properties[discriminator.property_name]
+            if discriminating_property.nil?
+              raise Messages.invalid_value(
+                name: 'discriminator property',
+                value: discriminator.property_name,
+                valid_values: properties.keys
+              )
+            end
+
+            discriminating_value = discriminating_property.reader.call(object)
+            if discriminating_value.nil?
+              discriminating_value = discriminating_property.default_value(context: context)
+
+              if discriminating_value.nil? && discriminator.default_mapping.nil?
+                raise "discriminating value can't be nil"
+              end
+            end
+
+            schema_name = discriminator.mapping(discriminating_value) || discriminating_value
+
+            schema = definitions.find_schema(schema_name)
+            if schema.nil?
+              default_mapping = discriminator.default_mapping
+              schema = definitions.find_schema(default_mapping) unless default_mapping.nil?
+
+              if schema.nil?
+                raise "inheriting schema couldn't be found: " \
+                      "#{[schema_name, default_mapping].compact.map(&:inspect).join(' or ')}"
+              end
+            end
+
+            Wrapper
+              .new(schema.resolve(definitions), definitions)
+              .resolve_schema(object, context: context)
+          end
+        end
+
         ##
         # :attr: additional_properties
         # The AdditionalProperties.
@@ -29,11 +85,13 @@ module Jsapi
 
         ##
         # :attr: properties
-        # The properties.
+        # The properties. Maps property names to Property objects.
         attribute :properties, { String => Property }, accessors: %i[reader writer]
 
         def add_property(name, keywords = {}) # :nodoc:
-          (@properties ||= {})[name.to_s] = Property.new(name, **keywords)
+          try_modify_attribute!(:properties) do
+            (@properties ||= {})[name.to_s] = Property.new(name, keywords)
+          end
         end
 
         def resolve_properties(definitions, context: nil)
@@ -49,48 +107,6 @@ module Jsapi
           end
         end
 
-        # Resolves the schema within +context+.
-        #
-        # Raises a +RuntimeError+ when the schema couldn't be resolved.
-        def resolve_schema(object, definitions, context: nil)
-          return self if discriminator.nil?
-
-          properties = resolve_properties(definitions, context: context)
-
-          discriminating_property = properties[discriminator.property_name]
-          if discriminating_property.nil?
-            raise InvalidValueError.new('discriminator property',
-                                        discriminator.property_name,
-                                        valid_values: properties.keys)
-          end
-
-          discriminating_value = discriminating_property.reader.call(object)
-          if discriminating_value.nil?
-            discriminating_value = discriminating_property.default_value(
-              definitions,
-              context: context
-            )
-            if discriminating_value.nil? && discriminator.default_mapping.nil?
-              raise "discriminating value can't be nil"
-            end
-          end
-
-          schema_name = discriminator.mapping(discriminating_value) || discriminating_value
-
-          schema = definitions.find_schema(schema_name)
-          if schema.nil?
-            default_mapping = discriminator.default_mapping
-            schema = definitions.find_schema(default_mapping) unless default_mapping.nil?
-
-            if schema.nil?
-              raise "inheriting schema couldn't be found: " \
-                    "#{[schema_name, default_mapping].compact.map(&:inspect).join(' or ')}"
-            end
-          end
-
-          schema.resolve(definitions).resolve_schema(object, definitions, context: context)
-        end
-
         def to_json_schema # :nodoc:
           super.merge(
             allOf: all_of_references.map(&:to_json_schema).presence,

data/lib/jsapi/meta/schema/reference.rb

@@ -7,16 +7,9 @@ module Jsapi
       class Reference < Model::Reference
         ##
         # :attr: existence
-        # The level of Existence. The default level of existence is +ALLOW_OMITTED+.
+        # Overrides the level of existence of the referred schema.
         attribute :existence, Existence, default: Existence::ALLOW_OMITTED
 
-        def resolve(definitions) # :nodoc:
-          schema = super
-          return schema if existence < Existence::ALLOW_EMPTY
-
-          Delegator.new(schema, [existence, schema.existence].max)
-        end
-
         # Returns a hash representing the \JSON \Schema reference object.
         def to_json_schema
           { '$ref': "#/definitions/#{ref}" }

data/lib/jsapi/meta/schema/string.rb

@@ -27,18 +27,24 @@ module Jsapi
         attribute :pattern, accessors: %i[reader]
 
         def max_length=(value) # :nodoc:
-          add_validation('max_length', Validation::MaxLength.new(value))
-          @max_length = value
+          try_modify_attribute!(:max_length) do
+            add_validation('max_length', Validation::MaxLength.new(value))
+            @max_length = value
+          end
         end
 
         def min_length=(value) # :nodoc:
-          add_validation('min_length', Validation::MinLength.new(value))
-          @min_length = value
+          try_modify_attribute!(:min_length) do
+            add_validation('min_length', Validation::MinLength.new(value))
+            @min_length = value
+          end
         end
 
         def pattern=(value) # :nodoc:
-          add_validation('pattern', Validation::Pattern.new(value))
-          @pattern = value
+          try_modify_attribute!(:pattern) do
+            add_validation('pattern', Validation::Pattern.new(value))
+            @pattern = value
+          end
         end
 
         def to_json_schema # :nodoc:

data/lib/jsapi/meta/schema/wrapper.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Jsapi
+  module Meta
+    module Schema
+      class Wrapper < Model::Wrapper
+        # The level of existence.
+        attr_reader :existence
+
+        def initialize(schema, definitions)
+          @existence =
+            [schema.existence].tap do |levels|
+              s = schema
+              while s.is_a?(Reference)
+                s = s.resolve(definitions, deep: false)
+                levels << s.existence
+              end
+            end.compact.max || Existence::ALLOW_OMITTED
+          super
+        end
+
+        # Returns the default value within +context+.
+        def default_value(context: nil)
+          return default unless default.nil?
+
+          definitions.default_value(type, context: context)
+        end
+      end
+    end
+  end
+end

data/lib/jsapi/meta/schema.rb

@@ -3,12 +3,12 @@
 require_relative 'schema/additional_properties'
 require_relative 'schema/conversion'
 require_relative 'schema/boundary'
-require_relative 'schema/delegator'
 require_relative 'schema/discriminator'
 require_relative 'schema/reference'
 require_relative 'schema/validation'
 
 require_relative 'schema/base'
+require_relative 'schema/wrapper'
 require_relative 'schema/array'
 require_relative 'schema/boolean'
 require_relative 'schema/numeric'
@@ -20,12 +20,6 @@ require_relative 'schema/string'
 module Jsapi
   module Meta
     module Schema
-      TYPES = %w[array boolean integer number object string].freeze # :nodoc:
-
-      TYPES.each do |type|
-        Base.define_method("#{type}?") { self.type == type }
-      end
-
       class << self
         # Creates a new schema. The +:type+ keyword determines the type of the schema to be
         # created. Possible types are:
@@ -39,7 +33,7 @@ module Jsapi
         #
         # The default type is <code>"object"</code>.
         #
-        # Raises an InvalidArgumentError if the given type is invalid.
+        # Raises an ArgumentError if the given type is invalid.
         def new(keywords = {})
           return Reference.new(keywords) if keywords.key?(:ref)
 
@@ -58,9 +52,28 @@ module Jsapi
           when 'string'
             String
           else
-            raise InvalidArgumentError.new('type', type, valid_values: TYPES)
+            raise ArgumentError, Messages.invalid_value(
+              name: 'type',
+              value: type,
+              valid_values: TYPES
+            )
           end.new(keywords.except(:type))
         end
+
+        # Wraps +schema+.
+        def wrap(schema, definitions)
+          return if schema.nil?
+          return schema if schema.is_a?(Wrapper)
+
+          case schema.resolve(definitions).type
+          when 'array'
+            Array::Wrapper
+          when 'object'
+            Object::Wrapper
+          else
+            Wrapper
+          end.new(schema, definitions)
+        end
       end
     end
   end

data/lib/jsapi/meta/security_requirement.rb

@@ -7,13 +7,13 @@ module Jsapi
       class Scheme < Model::Base
         ##
         # :attr: scopes
-        # The array of scopes.
+        # The scopes.
         attribute :scopes, [String]
       end
 
       ##
       # :attr_reader: schemes
-      # The schemes.
+      # The schemes. Maps strings to Scheme objects.
       attribute :schemes, { String => Scheme }
 
       # Returns a hash representing the \OpenAPI security requirement object.

data/lib/jsapi/meta/security_scheme/api_key.rb

@@ -27,8 +27,11 @@ module Jsapi
         def to_openapi(version, *)
           version = OpenAPI::Version.from(version)
 
-          with_openapi_extensions(
-            base_openapi_fields('apiKey', version).merge(name: name, in: self.in)
+          openapi_security_scheme_object(
+            'apiKey',
+            version,
+            name: name,
+            in: self.in
           )
         end
       end

data/lib/jsapi/meta/security_scheme/base.rb

@@ -11,18 +11,20 @@ module Jsapi
 
         ##
         # :attr: deprecated
-        # Specifies whether or not the security scheme is deprecated.
+        # Specifies whether the security scheme is marked as deprecated.
+        #
         # Applies to \OpenAPI 3.2 and higher.
         attribute :deprecated, values: [true, false]
 
         private
 
-        def base_openapi_fields(type, version)
-          {
+        def openapi_security_scheme_object(type, version, **keywords)
+          with_openapi_extensions(
             type: type,
             description: description,
-            deprecated: (deprecated?.presence if version >= OpenAPI::V3_2)
-          }
+            deprecated: (deprecated?.presence if version >= OpenAPI::V3_2),
+            **keywords
+          )
         end
       end
     end

data/lib/jsapi/meta/security_scheme/http/basic.rb

@@ -12,13 +12,11 @@ module Jsapi
           def to_openapi(version, *)
             version = OpenAPI::Version.from(version)
 
-            with_openapi_extensions(
-              if version < OpenAPI::V3_0
-                base_openapi_fields('basic', version)
-              else
-                base_openapi_fields('http', version).merge(scheme: 'basic')
-              end
-            )
+            if version < OpenAPI::V3_0
+              openapi_security_scheme_object('basic', version)
+            else
+              openapi_security_scheme_object('http', version, scheme: 'basic')
+            end
           end
         end
       end

data/lib/jsapi/meta/security_scheme/http/bearer.rb

@@ -22,11 +22,11 @@ module Jsapi
             version = OpenAPI::Version.from(version)
             return if version < OpenAPI::V3_0
 
-            with_openapi_extensions(
-              base_openapi_fields('http', version).merge(
-                scheme: 'bearer',
-                bearerFormat: bearer_format
-              )
+            openapi_security_scheme_object(
+              'http',
+              version,
+              scheme: 'bearer',
+              bearerFormat: bearer_format
             )
           end
         end

data/lib/jsapi/meta/security_scheme/http/other.rb

@@ -23,9 +23,7 @@ module Jsapi
             version = OpenAPI::Version.from(version)
             return if version < OpenAPI::V3_0
 
-            with_openapi_extensions(
-              base_openapi_fields('http', version).merge(scheme: scheme)
-            )
+            openapi_security_scheme_object('http', version, scheme: scheme)
           end
         end
       end

data/lib/jsapi/meta/security_scheme/mutual_tls.rb

@@ -13,9 +13,7 @@ module Jsapi
           version = OpenAPI::Version.from(version)
           return if version < OpenAPI::V3_1
 
-          with_openapi_extensions(
-            base_openapi_fields('mutualTLS', version)
-          )
+          openapi_security_scheme_object('mutualTLS', version)
         end
       end
     end

data/lib/jsapi/meta/security_scheme/oauth2.rb

@@ -25,9 +25,11 @@ module Jsapi
                            device_authorization
                            implicit
                            password]
+
         ##
         # :attr: oauth2_metadata_url
         # The URL of the OAuth2 authorization server metadata.
+        #
         # Applies to \OpenAPI 3.2 and higher.
         attribute :oauth2_metadata_url, String
 
@@ -35,23 +37,26 @@ module Jsapi
         def to_openapi(version, *)
           version = OpenAPI::Version.from(version)
 
-          with_openapi_extensions(
-            base_openapi_fields('oauth2', version).tap do |fields|
-              flows = oauth_flows
-              flows = flows.except('device_authorization') unless version >= OpenAPI::V3_2
-
-              if version >= OpenAPI::V3_0
-                fields[:flows] = flows.to_h do |key, value|
-                  [key.to_s.camelize(:lower).to_sym, value.to_openapi(version)]
-                end if flows.any?
+          flows = oauth_flows
+          flows = flows.except('device_authorization') if version < OpenAPI::V3_2
 
-                fields[:oauth2MetadataUrl] = oauth2_metadata_url if version >= OpenAPI::V3_2
+          openapi_security_scheme_object(
+            'oauth2',
+            version,
+            **if version >= OpenAPI::V3_0
+                {
+                  flows:
+                    flows.to_h do |key, value|
+                      [key.to_s.camelize(:lower), value.to_openapi(version)]
+                    end.presence,
+                  oauth2MetadataUrl: (oauth2_metadata_url if version >= OpenAPI::V3_2)
+                }
               elsif flows.one?
                 key, flow = flows.first
-                fields[:flow] = key.to_s
-                fields.merge!(flow.to_openapi(version))
+                { flow: key, **flow.to_openapi(version) }
+              else
+                {}
               end
-            end
           )
         end
       end

data/lib/jsapi/meta/security_scheme/open_id_connect.rb

@@ -17,10 +17,10 @@ module Jsapi
           version = OpenAPI::Version.from(version)
           return if version < OpenAPI::V3_0
 
-          with_openapi_extensions(
-            base_openapi_fields('openIdConnect', version).merge(
-              openIdConnectUrl: open_id_connect_url
-            )
+          openapi_security_scheme_object(
+            'openIdConnect',
+            version,
+            openIdConnectUrl: open_id_connect_url
           )
         end
       end

data/lib/jsapi/meta/security_scheme.rb

@@ -20,7 +20,7 @@ module Jsapi
         # - <code>"oauth2"</code>
         # - <code>"open_id_connect"</code>
         #
-        # Raises an InvalidArgumentError if the given type is invalid.
+        # Raises an ArgumentError if the given type is invalid.
         def new(keywords = {})
           type = keywords[:type]
           keywords = keywords.except(:type)
@@ -39,9 +39,9 @@ module Jsapi
           when 'open_id_connect' # OpenAPI 3.0 and higher
             OpenIDConnect.new(keywords)
           else
-            raise InvalidArgumentError.new(
-              'type',
-              type,
+            raise ArgumentError.new(
+              name: 'type',
+              value: type,
               valid_values: %w[api_key basic http oauth2 open_id_connect]
             )
           end

data/lib/jsapi/meta/server.rb

@@ -13,7 +13,9 @@ module Jsapi
 
       ##
       # :attr: name
-      # The optional unique name of the server. Applies to \OpenAPI 3.2 and higher.
+      # The optional unique name of the server.
+      #
+      # Applies to \OpenAPI 3.2 and higher.
       attribute :name, String
 
       ##
@@ -23,7 +25,7 @@ module Jsapi
 
       ##
       # :attr_reader: variables
-      # The ServerVariable objects.
+      # The server variables. Maps strings to ServerVariable objects.
       attribute :variables, { String => ServerVariable }
 
       # Returns a hash representing the \OpenAPI server object.

data/lib/jsapi/meta/tag.rb

@@ -18,7 +18,9 @@ module Jsapi
 
       ##
       # :attr: kind
-      # The category of the tag. Applies to \OpenAPI 3.2 and higher.
+      # The category of the tag.
+      #
+      # Applies to \OpenAPI 3.2 and higher.
       attribute :kind, String
 
       ##
@@ -28,12 +30,16 @@ module Jsapi
 
       ##
       # :attr: parent
-      # The name of the parent tag. Applies to \OpenAPI 3.2 and higher.
+      # The name of the parent tag.
+      #
+      # Applies to \OpenAPI 3.2 and higher.
       attribute :parent, String
 
       ##
       # :attr: summary
-      # The short summary of the tag. Applies to \OpenAPI 3.2 and higher.
+      # The short summary of the tag.
+      #
+      # Applies to \OpenAPI 3.2 and higher.
       attribute :summary, String
 
       # Returns a hash representing the \OpenAPI tag object.

data/lib/jsapi/meta.rb

@@ -22,12 +22,13 @@ require_relative 'meta/security_requirement'
 require_relative 'meta/link'
 require_relative 'meta/property'
 require_relative 'meta/schema'
+require_relative 'meta/content'
 require_relative 'meta/request_body'
 require_relative 'meta/parameter'
 require_relative 'meta/pathname'
-require_relative 'meta/path'
 require_relative 'meta/response'
 require_relative 'meta/operation'
+require_relative 'meta/path'
 require_relative 'meta/rescue_handler'
 require_relative 'meta/definitions'
 

data/lib/jsapi/model/base.rb

@@ -86,7 +86,7 @@ module Jsapi
         "#{attributes.map { |k, v| "#{k}: #{v.inspect}" }.join(', ')}>"
       end
 
-      def respond_to_missing?(param1, _param2) # :nodoc:
+      def respond_to_missing?(param1, *) # :nodoc:
         _attr_readers.key?(param1.to_s) ? true : super
       end
 

data/lib/jsapi/status/base.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Jsapi
+  module Status
+    class Base
+      include Comparable
+
+      attr_reader :priority, :value
+
+      delegate :hash, :to_s, to: :value
+
+      def initialize(value, priority:)
+        @priority = priority
+        @value = value
+      end
+
+      def ==(other) # :nodoc:
+        other.is_a?(self.class) && other.value == value
+      end
+
+      alias eql? ==
+
+      def <=>(other) # :nodoc:
+        result = priority <=> other.priority
+        return result unless result.zero?
+
+        value <=> other.value
+      end
+
+      def inspect # :nodoc:
+        "#<#{self.class} #{value.inspect}>"
+      end
+    end
+  end
+end