jsapi 0.6.1 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cb2e35d1d98201647ee5ec6087437891fc7781e94c717804275a6ed1ee870267
-  data.tar.gz: 1295f4128a5e096e64be1243f532ada34a58032860b87515836697ee48c7a51f
+  metadata.gz: ba5cf0667b03c271ef93b725cbcdcc25d51b2afaf33efe43372c66880ae46996
+  data.tar.gz: 1826d5fbc22a972c8f38476a45eff4052930480d7b1a195255422de272d181a4
 SHA512:
-  metadata.gz: 0f826bdf8be20affd8181feaf0f507705cf87ab9960711e1715dd4b2a7abb6ba072654532e99a7701359b8a38685f80c19aa39be1e0538f27befd460a8c8c74c
-  data.tar.gz: fbd3593855e17a5e6621e572ed292073d5849f802dc39febbb20d59e0f2a3133118cbc1c84413f8cfbd4a17047d28b5989a476abe8904f6a0c2f8390abda4dbf
+  metadata.gz: 63ca2ff516d31035884694dfb5a1969b1a697800f9afe694d30e6d250ca181bca0ae71d096d3e566d7de4a50f326233e9e5c9c3f199f38171d65bd27e36e6dec
+  data.tar.gz: f1b25727248b4bad12b2d57d665f86ee2f75fe826de22cd1d86b4e435152e8c0d2cb07152666b23a61bfb14d3810d516f3eeee53369f6f837559efc29156e996

data/lib/jsapi/controller/methods.rb

@@ -35,7 +35,7 @@ module Jsapi
       #
       # Raises an InvalidArgumentError when the value of +:omit+ is invalid.
       def api_operation(operation_name = nil, omit: nil, status: nil, strong: false, &block)
-        _perform_api_operation(
+        _api_operation(
           operation_name,
           bang: false,
           omit: omit,
@@ -53,7 +53,7 @@ module Jsapi
       #   end
       #
       def api_operation!(operation_name = nil, omit: nil, status: nil, strong: false, &block)
-        _perform_api_operation(
+        _api_operation(
           operation_name,
           bang: true,
           omit: omit,
@@ -78,7 +78,7 @@ module Jsapi
       def api_params(operation_name = nil, strong: false)
         definitions = api_definitions
         _api_params(
-          _api_operation(operation_name, definitions),
+          _find_api_operation(operation_name, definitions),
           definitions,
           strong: strong
         )
@@ -100,7 +100,7 @@ module Jsapi
       # Raises an InvalidArgumentError when the value of +:omit+ is invalid.
       def api_response(result, operation_name = nil, omit: nil, status: nil)
         definitions = api_definitions
-        operation = _api_operation(operation_name, definitions)
+        operation = _find_api_operation(operation_name, definitions)
         response = _api_response(operation, status, definitions)
 
         Response.new(result, response, api_definitions, omit: omit)
@@ -108,35 +108,9 @@ module Jsapi
 
       private
 
-      def _api_operation(operation_name, definitions)
-        operation = definitions.operation(operation_name)
-        return operation if operation
-
-        raise "operation not defined: #{operation_name}"
-      end
-
-      def _api_params(operation, definitions, strong:)
-        (operation.model || Model::Base).new(
-          Parameters.new(
-            params.except(:action, :controller, :format).permit!,
-            headers,
-            operation,
-            definitions,
-            strong: strong
-          )
-        )
-      end
-
-      def _api_response(operation, status, definitions)
-        response = operation.response(status)
-        return response.resolve(definitions) if response
-
-        raise "status code not defined: #{status}"
-      end
-
-      def _perform_api_operation(operation_name, bang:, omit:, status:, strong:, &block)
+      def _api_operation(operation_name, bang:, omit:, status:, strong:, &block)
         definitions = api_definitions
-        operation = _api_operation(operation_name, definitions)
+        operation = _find_api_operation(operation_name, definitions)
         response = _api_response(operation, status, definitions)
 
         if block
@@ -172,6 +146,32 @@ module Jsapi
         end
         self.content_type = response.content_type
       end
+
+      def _api_params(operation, definitions, strong:)
+        (operation.model || Model::Base).new(
+          Parameters.new(
+            params.except(:action, :controller, :format).permit!,
+            headers,
+            operation,
+            definitions,
+            strong: strong
+          )
+        )
+      end
+
+      def _api_response(operation, status, definitions)
+        response = operation.response(status)
+        return response.resolve(definitions) if response
+
+        raise "status code not defined: #{status}"
+      end
+
+      def _find_api_operation(operation_name, definitions)
+        operation = definitions.find_operation(operation_name)
+        return operation if operation
+
+        raise "operation not defined: #{operation_name}"
+      end
     end
   end
 end

data/lib/jsapi/dsl/class_methods.rb

@@ -13,7 +13,10 @@ module Jsapi
 
       # The API definitions of the current class.
       def api_definitions(&block)
-        @api_definitions ||= Meta::Definitions.new(self)
+        @api_definitions ||= Meta::Definitions.new(
+          owner: self,
+          parent: superclass.try(:api_definitions)
+        )
         Definitions.new(@api_definitions, &block) if block
         @api_definitions
       end

data/lib/jsapi/dsl/definitions.rb

@@ -19,7 +19,7 @@ module Jsapi
       # Includes API definitions from +klasses+.
       def include(*klasses)
         klasses.each do |klass|
-          _meta_model.include(klass.api_definitions)
+          _meta_model.add_included(klass.api_definitions)
         end
       end
 
@@ -37,8 +37,8 @@ module Jsapi
       #   end
       def openapi(**keywords, &block)
         _define('openapi') do
-          _meta_model.openapi_root = keywords
-          OpenAPI::Root.new(_meta_model.openapi_root, &block) if block
+          _meta_model.openapi = keywords
+          OpenAPI::Root.new(_meta_model.openapi, &block) if block
         end
       end
 
@@ -88,7 +88,7 @@ module Jsapi
       #
       def rescue_from(*klasses, with: nil)
         klasses.each do |klass|
-          _meta_model.add_rescue_handler(klass, status: with)
+          _meta_model.add_rescue_handler({ error_class: klass, status: with })
         end
       end
 

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

@@ -6,11 +6,11 @@ module Jsapi
       module Attributes
         # Defines an attribute.
         def attribute(name, type = Object,
-                      keys: nil,
-                      values: nil,
                       default: nil,
                       default_key: nil,
-                      writer: true)
+                      keys: nil,
+                      read_only: false,
+                      values: nil)
 
           (@attribute_names ||= []) << name.to_sym
 
@@ -24,20 +24,19 @@ module Jsapi
 
           case type
           when Array
-            if writer
+            unless read_only
               singular_name = name.to_s.singularize
+              add_method = "add_#{singular_name}"
+
               type_caster = TypeCaster.new(type.first, values: values, name: singular_name)
 
               # Attribute writer
               define_method("#{name}=") do |argument|
-                instance_variable_set(
-                  instance_variable_name,
-                  Array.wrap(argument).map { |element| type_caster.cast(element) }
-                )
+                Array.wrap(argument).each { |element| send(add_method, element) }
               end
 
-              # add_{singular_name} method
-              define_method("add_#{singular_name}") do |argument = nil|
+              # Add method
+              define_method(add_method) do |argument = nil|
                 type_caster.cast(argument).tap do |casted_argument|
                   if instance_variable_defined?(instance_variable_name)
                     instance_variable_get(instance_variable_name)
@@ -49,20 +48,27 @@ module Jsapi
             end
           when Hash
             singular_name = name.to_s.singularize
+            add_method = "add_#{singular_name}"
+
             key_type, value_type = type.first
             key_type_caster = TypeCaster.new(key_type, values: keys, name: 'key')
 
-            # hash value reader
+            # Hash value reader
             define_method(singular_name) do |key = nil|
               key = default_key if key.to_s.empty?
               send(name)&.[](key_type_caster.cast(key))
             end
 
-            if writer
+            unless read_only
               value_type_caster = TypeCaster.new(value_type, values: values)
 
-              # add_{singular_name} method
-              define_method("add_#{singular_name}") do |key_or_value, value = nil|
+              # Attribute writer
+              define_method("#{name}=") do |argument|
+                argument.each { |key, value| send(add_method, key, value) }
+              end
+
+              # Add method
+              define_method(add_method) do |key_or_value, value = nil|
                 if value.nil? && default_key
                   key = default_key
                   value = key_or_value
@@ -89,7 +95,7 @@ module Jsapi
               value.nil? ? default || false : value
             end if values == [true, false]
 
-            if writer
+            unless read_only
               type_caster = TypeCaster.new(type, values: values, name: name)
 
               # Attribute writer

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

@@ -20,12 +20,13 @@ module Jsapi
           end
         end
 
-        def inspect # :nodoc:
+        def inspect(*attributes) # :nodoc:
           klass = self.class
+          attribute_names = klass.attribute_names
+          attribute_names = attributes & attribute_names if attributes.any?
+
           "#<#{klass.name} #{
-            klass.attribute_names.map do |name|
-              "#{name}: #{send(name).inspect}"
-            end.join(', ')
+            attribute_names.map { |name| "#{name}: #{send(name).inspect}" }.join(', ')
           }>"
         end
 

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

@@ -10,10 +10,9 @@ module Jsapi
         # The name of the referred object.
         attribute :ref, String
 
-        # Returns the name of the method to be called to look up the referred object
-        # in a Definitions instance.
-        def self.lookup_method_name
-          @lookup_method_name ||= name.delete_suffix('::Reference').demodulize.underscore
+        # Derrives the component type from the inner most module name.
+        def self.component_type
+          @component_type ||= name.split('::')[-2].underscore
         end
 
         # Returns true.
@@ -25,7 +24,7 @@ module Jsapi
         #
         # Raises a ReferenceError if +ref+ could not be resolved.
         def resolve(definitions)
-          object = definitions.send(self.class.lookup_method_name, ref)
+          object = definitions.find_component(self.class.component_type, ref)
           raise ReferenceError, ref if object.nil?
 
           object.resolve(definitions)

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

@@ -14,7 +14,8 @@ module Jsapi
         }
 
         # Creates a new type caster for +klass+.
-        def initialize(klass, name: 'value', values: nil)
+        def initialize(klass = nil, name: 'value', values: nil)
+          klass = Object if klass.nil?
           @caster =
             case klass.name
             when 'String'

data/lib/jsapi/meta/defaults.rb

@@ -7,12 +7,12 @@ module Jsapi
       ##
       # :attr: read
       # The default value of parameters and properties when reading requests.
-      attribute :within_requests, Object
+      attribute :within_requests
 
       ##
       # :attr: write
       # The default value of properties when writing responses.
-      attribute :within_responses, Object
+      attribute :within_responses
 
       # Returns the default value within +context+.
       def value(context:)

data/lib/jsapi/meta/definitions.rb

@@ -2,170 +2,225 @@
 
 module Jsapi
   module Meta
-    class Definitions
-      extend Base::Attributes
-
+    class Definitions < Base::Model
       ##
       # :attr: defaults
-      # The general default values.
+      # The Defaults.
       attribute :defaults, { String => Defaults }, keys: Schema::TYPES, default: {}
 
       ##
-      # :attr: openapi_root
-      # The OpenAPI::Root.
-      attribute :openapi_root, OpenAPI::Root
+      # :attr: included
+      # The Definitions included.
+      attribute :included, [Definitions], default: []
 
-      attr_reader :callbacks, :operations, :parameters, :request_bodies,
-                  :rescue_handlers, :responses, :schemas
+      ##
+      # :attr: on_rescues
+      # The methods or procs to be called when rescuing an exception.
+      attribute :on_rescues, [], default: []
 
-      def initialize(owner = nil)
-        @owner = owner
-        @callbacks = { on_rescue: [] }
-        @operations = {}
-        @parameters = {}
-        @request_bodies = {}
-        @rescue_handlers = []
-        @responses = {}
-        @schemas = {}
-        @self_and_included = [self]
-      end
+      ##
+      # :attr: openapi
+      # The OpenAPI root object.
+      attribute :openapi, OpenAPI
 
-      def add_on_rescue(method_or_proc)
-        @callbacks[:on_rescue] << method_or_proc
-      end
+      ##
+      # :attr: operations
+      # The Operation objects.
+      attribute :operations, { String => Operation }, default: {}
 
-      def add_operation(name = nil, keywords = {})
-        name = name.nil? ? default_operation_name : name.to_s
-        @operations[name] = Operation.new(name, keywords.reverse_merge(path: default_path))
-      end
+      ##
+      # :attr_reader: owner
+      # The class to which it is assigned.
+      attribute :owner, read_only: true
 
-      def add_parameter(name, keywords = {})
-        name = name.to_s
-        @parameters[name] = Parameter.new(name, keywords)
+      ##
+      # :attr: parameters
+      # The reusable Parameter objects.
+      attribute :parameters, { String => Parameter }, default: {}
+
+      ##
+      # :attr_reader: parent
+      # The Definitions from which it inherits.
+      attribute :parent, read_only: true
+
+      ##
+      # :attr: rescue_handlers
+      # The RescueHandler objects.
+      attribute :rescue_handlers, [RescueHandler], default: []
+
+      ##
+      # :attr: request_bodies
+      # The reusable RequestBody objects.
+      attribute :request_bodies, { String => RequestBody }, default: {}
+
+      ##
+      # :attr: responses
+      # The reusable Response objects.
+      attribute :responses, { String => Response }, default: {}
+
+      ##
+      # :attr: schemas
+      # The reusable Schema objects.
+      attribute :schemas, { String => Schema }, default: {}
+
+      undef add_included, add_operation, add_parameter
+
+      def initialize(keywords = {})
+        @owner = keywords.delete(:owner)
+        @parent = keywords.delete(:parent)
+
+        super(keywords)
       end
 
-      def add_request_body(name, keywords = {})
-        @request_bodies[name.to_s] = RequestBody.new(keywords)
+      def add_included(definitions) # :nodoc:
+        if circular_dependency?(definitions)
+          raise ArgumentError, 'detected circular dependency between ' \
+                               "#{owner.inspect} and " \
+                               "#{definitions.owner.inspect}"
+        end
+
+        (@included ||= []) << definitions
+        self
       end
 
-      def add_rescue_handler(klass, status: nil)
-        @rescue_handlers << RescueHandler.new(klass, status: status)
+      def add_operation(name = nil, keywords = {}) # :nodoc:
+        name = name.nil? ? default_operation_name : name.to_s
+        keywords = keywords.reverse_merge(path: default_path)
+        (@operations ||= {})[name] = Operation.new(name, keywords)
       end
 
-      def add_response(name, keywords = {})
+      def add_parameter(name, keywords = {}) # :nodoc:
         name = name.to_s
-        @responses[name] = Response.new(keywords)
+        (@parameters ||= {})[name] = Parameter.new(name, keywords)
       end
 
-      def add_schema(name, keywords = {})
-        name = name.to_s
-        @schemas[name] = Schema.new(keywords)
+      # Returns an array containing itself and all of the definitions inherited/included.
+      def ancestors
+        [self].tap do |ancestors|
+          (included + Array(parent)).each do |included_or_parent|
+            included_or_parent.ancestors.each do |definitions|
+              ancestors << definitions
+            end
+          end
+        end.uniq
       end
 
+      # Returns the default value for +type+ within +context+.
       def default_value(type, context: nil)
         return unless (type = type.to_s).present?
 
-        @self_and_included.each do |definitions|
+        ancestors.each do |definitions|
           default = definitions.default(type)
           return default.value(context: context) if default
         end
         nil
       end
 
-      def include(definitions)
-        return if @self_and_included.include?(definitions)
+      # Returns the component with the specified type and name.
+      def find_component(type, name)
+        return unless (name = name.to_s).present?
+
+        ancestors.each do |definitions|
+          component = definitions.send(type, name)
+          return component if component.present?
+        end
+        nil
+      end
+
+      # Returns the operation with the specified name.
+      def find_operation(name = nil)
+        return find_component(:operation, name) if name.present?
 
-        @self_and_included << definitions
+        # Return the one and only operation
+        operations.values.first if operations.one?
       end
 
-      def inspect # :nodoc:
-        "#<#{self.class.name} #{
-          %i[owner operations parameters request_bodies responses schemas
-             openapi_root rescue_handlers].map do |name|
-            "#{name}: #{instance_variable_get("@#{name}").inspect}"
-          end.join(', ')
-        }>"
+      def inspect(*attributes) # :nodoc:
+        super(*(attributes.presence || %i[owner parent included]))
       end
 
       # Returns a hash representing the \JSON \Schema document for +name+.
       def json_schema_document(name)
-        schema(name)&.to_json_schema&.tap do |hash|
-          definitions =
-            @self_and_included
-            .map(&:schemas)
-            .reduce(&:merge)
-            .except(name.to_s)
-            .transform_values(&:to_json_schema)
+        find_component(:schema, name)&.to_json_schema&.tap do |hash|
+          definitions = ancestors
+                        .map(&:schemas)
+                        .reduce(&:merge)
+                        .except(name.to_s)
+                        .transform_values(&:to_json_schema)
 
           hash[:definitions] = definitions if definitions.any?
         end
       end
 
+      # Returns the methods or procs to be called when rescuing an exception.
       def on_rescue_callbacks
-        @self_and_included.flat_map do |definitions|
-          definitions.callbacks[:on_rescue]
-        end
+        ancestors.flat_map(&:on_rescues)
       end
 
       # Returns a hash representing the \OpenAPI document for +version+.
-
+      #
       # Raises an +ArgumentError+ if +version+ is not supported.
       def openapi_document(version = nil)
         version = OpenAPI::Version.from(version)
 
-        (openapi_root&.to_openapi(version, self) || {}).tap do |h|
-          h[:paths] = openapi_paths(version)
+        operations = ancestors.map(&:operations).reduce(&:reverse_merge).values
+
+        components = if version.major == 2
+                       {
+                         definitions: :schemas,
+                         parameters: :parameters,
+                         responses: :responses
+                       }
+                     else
+                       {
+                         schemas: :schemas,
+                         parameters: :parameters,
+                         requestBodies: :request_bodies,
+                         responses: :responses
+                       }
+                     end
+
+        openapi_components = ancestors.map do |definitions|
+          components.transform_values do |method|
+            definitions.send(method).transform_values do |component|
+              case method
+              when :parameters
+                component.to_openapi(version, self).first
+              when :responses
+                component.to_openapi(version, self)
+              else
+                component.to_openapi(version)
+              end
+            end.presence
+          end.compact
+        end.reduce(&:reverse_merge)
+
+        (openapi&.to_openapi(version, self) || {}).tap do |h|
+          h[:paths] = operations
+                      .group_by { |operation| operation.path || default_path }
+                      .transform_values do |op|
+                        op.index_by(&:method).transform_values do |operation|
+                          operation.to_openapi(version, self)
+                        end
+                      end.presence
 
           if version.major == 2
-            h.merge!(
-              definitions: openapi_schemas(version),
-              parameters: openapi_parameters(version),
-              responses: openapi_responses(version)
-            )
-            operations = @self_and_included.map(&:operations).reduce(&:reverse_merge).values
-
             consumes = operations.filter_map { |operation| operation.consumes(self) }
             h[:consumes] = consumes.uniq.sort if consumes.present?
 
             produces = operations.flat_map { |operation| operation.produces(self) }
             h[:produces] = produces.uniq.sort if produces.present?
-          else
-            h[:components] = (h[:components] || {}).merge(
-              schemas: openapi_schemas(version),
-              parameters: openapi_parameters(version),
-              requestBodies: openapi_request_bodies(version),
-              responses: openapi_responses(version)
-            ).compact.presence
+
+            h.merge!(openapi_components)
+          elsif openapi_components.any?
+            (h[:components] ||= {}).merge!(openapi_components)
           end
         end.compact
       end
 
-      def operation(name = nil)
-        if (name = name.to_s).present?
-          definitions = @self_and_included.find { |d| d.operations.key?(name) }
-          definitions.operations[name] if definitions
-        elsif @operations.one?
-          # return the one and only operation
-          @operations.values.first
-        end
-      end
-
-      def parameter(name)
-        return unless (name = name.to_s).present?
-
-        definitions = @self_and_included.find { |d| d.parameters.key?(name) }
-        definitions.parameters[name] if definitions
-      end
-
-      def request_body(name)
-        return unless (name = name.to_s).present?
-
-        definitions = @self_and_included.find { |d| d.request_bodies.key?(name) }
-        definitions.request_bodies[name] if definitions
-      end
-
+      # Returns the first RescueHandler to handle +exception+, or nil if no one could be found.
       def rescue_handler_for(exception)
-        @self_and_included.each do |definitions|
+        ancestors.each do |definitions|
           definitions.rescue_handlers.each do |rescue_handler|
             return rescue_handler if rescue_handler.match?(exception)
           end
@@ -173,22 +228,15 @@ module Jsapi
         nil
       end
 
-      def response(name)
-        return unless (name = name.to_s).present?
-
-        definitions = @self_and_included.find { |d| d.responses.key?(name) }
-        definitions.responses[name] if definitions
-      end
+      private
 
-      def schema(name)
-        return unless (name = name.to_s).present?
+      def circular_dependency?(other)
+        return true if other == self
+        return false if other.included.none?
 
-        definitions = @self_and_included.find { |d| d.schemas.key?(name) }
-        definitions.schemas[name] if definitions
+        other.included.any? { |included| circular_dependency?(included) }
       end
 
-      private
-
       def default_operation_name
         @default_operation_name ||=
           @owner.to_s.demodulize.delete_suffix('Controller').underscore
@@ -197,46 +245,6 @@ module Jsapi
       def default_path
         @default_path ||= "/#{default_operation_name}"
       end
-
-      def openapi_parameters(version)
-        @self_and_included
-          .map(&:parameters).reduce(&:merge)
-          .transform_values do |parameter|
-          parameter.to_openapi(version, self).first
-        end.presence
-      end
-
-      def openapi_paths(version)
-        @self_and_included
-          .map(&:operations).reduce(&:merge).values
-          .group_by { |operation| operation.path || default_path }
-          .transform_values do |operations|
-          operations.index_by(&:method).transform_values do |operation|
-            operation.to_openapi(version, self)
-          end
-        end.presence
-      end
-
-      def openapi_request_bodies(version)
-        @self_and_included
-          .map(&:request_bodies).reduce(&:merge).transform_values do |request_body|
-            request_body.to_openapi(version)
-          end.presence
-      end
-
-      def openapi_responses(version)
-        @self_and_included
-          .map(&:responses).reduce(&:merge).transform_values do |response|
-          response.to_openapi(version, self)
-        end.presence
-      end
-
-      def openapi_schemas(version)
-        @self_and_included
-          .map(&:schemas).reduce(&:merge).transform_values do |schema|
-          schema.to_openapi(version)
-        end.presence
-      end
     end
   end
 end

data/lib/jsapi/meta/openapi/callback/model.rb

@@ -8,7 +8,9 @@ module Jsapi
         class Model < Meta::Base::Model
           ##
           # :attr: operations
-          attribute :operations, writer: false, default: {}
+          attribute :operations, { String => Object }, default: {}
+
+          undef add_operation
 
           # Adds a callback operation.
           #
@@ -19,10 +21,6 @@ module Jsapi
             (@operations ||= {})[expression.to_s] = Operation.new(nil, keywords)
           end
 
-          def operation(expression) # :nodoc:
-            @operations&.[](expression&.to_s)
-          end
-
           # Returns a hash representing the \OpenAPI callback object.
           def to_openapi(version, definitions)
             operations.transform_values do |operation|

data/lib/jsapi/meta/openapi/extensions.rb

@@ -4,6 +4,10 @@ module Jsapi
   module Meta
     module OpenAPI
       module Extensions
+        ##
+        # :attr: openapi_extensions
+        # The \OpenAPI extensions.
+
         # Adds an \OpenAPI extension.
         #
         # Raises an +ArgumentError+ if +name+ is blank.
@@ -13,11 +17,18 @@ module Jsapi
           openapi_extensions["x-#{name}".to_sym] = value
         end
 
-        # Returns a hash containing the \OpenAPI extensions.
-        def openapi_extensions
+        def openapi_extensions # :nodoc:
           @openapi_extensions ||= {}
         end
 
+        def openapi_extensions=(extensions) # :nodoc:
+          @openapi_extensions = {}
+
+          extensions.each do |name, value|
+            add_openapi_extension(name, value)
+          end
+        end
+
         private
 
         def with_openapi_extensions(keywords = {}) # :nodoc:

data/lib/jsapi/meta/openapi/header/model.rb

@@ -39,14 +39,17 @@ module Jsapi
           ##
           # :attr_reader: schema
           # The Schema of the header.
-          attribute :schema, writer: false
+          attribute :schema, read_only: true
 
           def initialize(keywords = {})
             raise ArgumentError, "type can't be object" if keywords[:type] == 'object'
 
             keywords = keywords.dup
-            super(keywords.extract!(:collection_format, :deprecated, :description, :examples))
-
+            super(
+              keywords.extract!(
+                :collection_format, :deprecated, :description, :examples, :openapi_extensions
+              )
+            )
             add_example(value: keywords.delete(:example)) if keywords.key?(:example)
 
             @schema = Schema.new(keywords)

data/lib/jsapi/meta/openapi.rb

@@ -17,3 +17,16 @@ require_relative 'openapi/server'
 require_relative 'openapi/link'
 require_relative 'openapi/tag'
 require_relative 'openapi/root'
+
+module Jsapi
+  module Meta
+    module OpenAPI
+      class << self
+        # Creates a new \OpenAPI root object.
+        def new(keywords = {})
+          Root.new(keywords)
+        end
+      end
+    end
+  end
+end

data/lib/jsapi/meta/operation.rb

@@ -48,12 +48,12 @@ module Jsapi
       ##
       # :attr_reader: name
       # The name of the operation.
-      attribute :name, writer: false
+      attribute :name, read_only: true
 
       ##
       # :attr: parameters
       # The parameters of the operation.
-      attribute :parameters, { String => Parameter }, default: {}, writer: false
+      attribute :parameters, { String => Parameter }, default: {}
 
       ##
       # :attr: path
@@ -104,6 +104,8 @@ module Jsapi
       # The tags used to group operations in an \OpenAPI document.
       attribute :tags, [String]
 
+      undef :add_parameter
+
       def initialize(name = nil, keywords = {})
         @name = name&.to_s
         super(keywords)

data/lib/jsapi/meta/parameter/model.rb

@@ -37,12 +37,12 @@ module Jsapi
         ##
         # :attr_reader: name
         # The name of the parameter.
-        attribute :name, writer: false
+        attribute :name, read_only: true
 
         ##
         # :attr_reader: schema
         # The Schema of the parameter.
-        attribute :schema, writer: false
+        attribute :schema, read_only: true
 
         # Creates a new parameter.
         #
@@ -53,7 +53,7 @@ module Jsapi
           @name = name.to_s
 
           keywords = keywords.dup
-          super(keywords.extract!(:deprecated, :description, :examples, :in))
+          super(keywords.extract!(:deprecated, :description, :examples, :in, :openapi_extensions))
 
           add_example(value: keywords.delete(:example)) if keywords.key?(:example)
           keywords[:ref] = keywords.delete(:schema) if keywords.key?(:schema)

data/lib/jsapi/meta/property.rb

@@ -8,7 +8,7 @@ module Jsapi
       ##
       # :attr_reader: name
       # The name of the property.
-      attribute :name, writer: false
+      attribute :name, read_only: true
 
       ##
       # :attr: read_only
@@ -17,7 +17,7 @@ module Jsapi
       ##
       # :attr_reader: schema
       # The Schema of the parameter.
-      attribute :schema, writer: false
+      attribute :schema, read_only: true
 
       ##
       # :attr: source

data/lib/jsapi/meta/request_body/model.rb

@@ -26,11 +26,11 @@ module Jsapi
         ##
         # :attr_reader: schema
         # The Schema of the request body.
-        attribute :schema, writer: false
+        attribute :schema, read_only: true
 
         def initialize(keywords = {})
           keywords = keywords.dup
-          super(keywords.extract!(:content_type, :description, :examples))
+          super(keywords.extract!(:content_type, :description, :examples, :openapi_extensions))
 
           add_example(value: keywords.delete(:example)) if keywords.key?(:example)
           keywords[:ref] = keywords.delete(:schema) if keywords.key?(:schema)

data/lib/jsapi/meta/rescue_handler.rb

@@ -2,31 +2,31 @@
 
 module Jsapi
   module Meta
-    # Maps a +StandardError+ class to a response status.
-    class RescueHandler
-      # The response status.
-      attr_reader :status
+    # Maps an error class to a response status.
+    class RescueHandler < Base::Model
+      ##
+      # :attr: error_class
+      # The error class to be mapped.
+      attribute :error_class, default: StandardError
 
-      # Creates a new rescue handler to map +klass+ to +status+. The default response status
-      # is <code>"default"</code>.
-      #
-      # Raises an +ArgumentError+ if +klass+ isn't a +StandardError+ class.
-      def initialize(klass, status: nil)
-        unless klass.is_a?(Class) && klass.ancestors.include?(StandardError)
-          raise ArgumentError, "#{klass.inspect} must be a standard error class"
-        end
-
-        @klass = klass
-        @status = status || 'default'
-      end
+      ##
+      # :attr: status
+      # The response status. The default is <code>"default"</code>.
+      attribute :status, default: 'default'
 
-      def inspect # :nodoc:
-        "#<#{self.class.name} class: #{@klass}, status: #{@status.inspect}>"
+      def initialize(keywords = {})
+        super
+        unless error_class.is_a?(Class)
+          raise ArgumentError, "#{error_class.inspect} isn't a class"
+        end
+        unless error_class <= StandardError
+          raise ArgumentError, "#{error_class.inspect} isn't a rescuable class"
+        end
       end
 
       # Returns true if +exception+ is an instance of the class to be mapped, false otherwise.
       def match?(exception)
-        exception.is_a?(@klass)
+        exception.is_a?(error_class)
       end
     end
   end

data/lib/jsapi/meta/response/model.rb

@@ -41,16 +41,20 @@ module Jsapi
         ##
         # :attr_reader: schema
         # The Schema of the response.
-        attribute :schema, writer: false
+        attribute :schema, read_only: true
 
         def initialize(keywords = {})
           keywords = keywords.dup
-          super(keywords.extract!(:content_type, :description, :examples, :locale))
-
+          super(
+            keywords.extract!(
+              :content_type, :description, :examples, :headers,
+              :links, :locale, :openapi_extensions
+            )
+          )
           add_example(value: keywords.delete(:example)) if keywords.key?(:example)
           keywords[:ref] = keywords.delete(:schema) if keywords.key?(:schema)
 
-          @schema = Schema.new(**keywords)
+          @schema = Schema.new(keywords)
         end
 
         # Returns a hash representing the \OpenAPI response object.

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

@@ -9,7 +9,7 @@ module Jsapi
         ##
         # :attr: schema
         # The Schema of additional properties.
-        attribute :schema, Schema, writer: false
+        attribute :schema, read_only: true
 
         ##
         # :attr: source

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

@@ -7,17 +7,19 @@ module Jsapi
         ##
         # :attr: items
         # The Schema defining the kind of items.
-        attribute :items, Schema, writer: false
+        attribute :items, Schema
 
         ##
         # :attr: max_items
         # The maximum length of an array.
-        attribute :max_items, writer: false
+        attribute :max_items
 
         ##
         # :attr: min_items
         # The minimum length of an array.
-        attribute :min_items, writer: false
+        attribute :min_items
+
+        undef items=, max_items=, min_items=
 
         def items=(keywords = {}) # :nodoc:
           if keywords.key?(:schema)

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

@@ -24,12 +24,12 @@ module Jsapi
         ##
         # :attr: enum
         # The allowed values.
-        attribute :enum, writer: false
+        attribute :enum
 
         ##
         # :attr: examples
         # The samples matching the schema.
-        attribute :examples, [::Object]
+        attribute :examples, []
 
         ##
         # :attr: external_docs
@@ -53,6 +53,8 @@ module Jsapi
         # The validations.
         attr_reader :validations
 
+        undef enum=
+
         # Creates a new schema.
         def initialize(keywords = {})
           keywords = keywords.dup

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

@@ -9,16 +9,18 @@ module Jsapi
         ##
         # :attr: maximum
         # The (exclusive) maximum.
-        attribute :maximum, writer: false
+        attribute :maximum
 
         ##
         # :attr: minimum
         # The (exclusive) minimum.
-        attribute :minimum, writer: false
+        attribute :minimum
 
         ##
         # :attr: multiple_of
-        attribute :multiple_of, writer: false
+        attribute :multiple_of
+
+        undef maximum=, minimum=, multiple_of=
 
         def maximum=(value) # :nodoc:
           boundary = Boundary.from(value)

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

@@ -30,7 +30,9 @@ module Jsapi
         ##
         # :attr: properties
         # The properties.
-        attribute :properties, { String => Property }, writer: false, default: {}
+        attribute :properties, { String => Property }, default: {}
+
+        undef add_property
 
         def add_property(name, keywords = {}) # :nodoc:
           (@properties ||= {})[name.to_s] = Property.new(name, **keywords)
@@ -64,9 +66,9 @@ module Jsapi
 
           value = property.reader.call(object)
           value = property.default_value(definitions, context: context) if value.nil?
-          raise "#{discriminator.property_name} can't be blank" if value.blank?
+          raise "#{discriminator.property_name} can't be nil" if value.nil?
 
-          schema = definitions.schema(discriminator.mapping(value) || value)
+          schema = definitions.find_component(:schema, discriminator.mapping(value) || value)
           raise "inheriting schema couldn't be found: #{value.inspect}" if schema.nil?
 
           schema.resolve(definitions).resolve_schema(object, definitions, context: context)

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

@@ -14,17 +14,19 @@ module Jsapi
         ##
         # :attr: max_length
         # The maximum length of a string.
-        attribute :max_length, writer: false
+        attribute :max_length
 
         ##
         # :attr: min_length
         # The minimum length of a string.
-        attribute :min_length, writer: false
+        attribute :min_length
 
         ##
         # :attr: pattern
         # The regular expression a string must match.
-        attribute :pattern, writer: false
+        attribute :pattern
+
+        undef max_length=, min_length=, pattern=
 
         def max_length=(value) # :nodoc:
           add_validation('max_length', Validation::MaxLength.new(value))

data/lib/jsapi/version.rb

@@ -5,6 +5,6 @@ module Jsapi
     # NOTE: See https://bundler.io/guides/creating_gem.html
 
     # The current GEM version.
-    VERSION = '0.6.1'
+    VERSION = '0.7.0'
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: jsapi
 version: !ruby/object:Gem::Version
-  version: 0.6.1
+  version: 0.7.0
 platform: ruby
 authors:
 - Denis Göller
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-09-17 00:00:00.000000000 Z
+date: 2024-09-21 00:00:00.000000000 Z
 dependencies: []
 description: Jsapi can be used to read requests, produce responses and create OpenAPI
   documents