jsapi 0.7.0 → 0.7.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ba5cf0667b03c271ef93b725cbcdcc25d51b2afaf33efe43372c66880ae46996
-  data.tar.gz: 1826d5fbc22a972c8f38476a45eff4052930480d7b1a195255422de272d181a4
+  metadata.gz: e1726601746ec435ff292f43b0f9e415b9d75298c3ff767d38f32e7a80ec1089
+  data.tar.gz: 33d5995c7b8dda3b74c8ab01c4c75eb481666fce3c9a63d22ea662a2b1b3d297
 SHA512:
-  metadata.gz: 63ca2ff516d31035884694dfb5a1969b1a697800f9afe694d30e6d250ca181bca0ae71d096d3e566d7de4a50f326233e9e5c9c3f199f38171d65bd27e36e6dec
-  data.tar.gz: f1b25727248b4bad12b2d57d665f86ee2f75fe826de22cd1d86b4e435152e8c0d2cb07152666b23a61bfb14d3810d516f3eeee53369f6f837559efc29156e996
+  metadata.gz: cc78c78dd32ded46d63fb7d320378fa8b613d35a82e095473500e725bfbbe822097b0ee25d4376f9b240477181b4f00f0320ac1256515b8f24bdd025f62c2f91
+  data.tar.gz: eef5aac75b9c5094a5a9504eed38e1413fd38fd2becfc65b1830a604afb332609240a11c55db2d029c7ac0867a011a470dc4d46cf7f92e62a50a6b7a365aaf46

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.add_included(klass.api_definitions)
+          _meta_model.include(klass.api_definitions)
         end
       end
 

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

@@ -6,6 +6,7 @@ module Jsapi
       module Attributes
         # Defines an attribute.
         def attribute(name, type = Object,
+                      add_method: nil,
                       default: nil,
                       default_key: nil,
                       keys: nil,
@@ -26,13 +27,18 @@ module Jsapi
           when Array
             unless read_only
               singular_name = name.to_s.singularize
-              add_method = "add_#{singular_name}"
+              add_method = "add_#{singular_name}" if add_method.nil?
 
               type_caster = TypeCaster.new(type.first, values: values, name: singular_name)
 
               # Attribute writer
               define_method("#{name}=") do |argument|
-                Array.wrap(argument).each { |element| send(add_method, element) }
+                if argument.nil?
+                  instance_variable_set(instance_variable_name, nil)
+                else
+                  instance_variable_set(instance_variable_name, [])
+                  Array.wrap(argument).each { |element| send(add_method, element) }
+                end
               end
 
               # Add method
@@ -43,28 +49,35 @@ module Jsapi
                   else
                     instance_variable_set(instance_variable_name, [])
                   end << casted_argument
+                  attribute_changed(name)
                 end
               end
             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
+            # Lookup method
             define_method(singular_name) do |key = nil|
               key = default_key if key.to_s.empty?
               send(name)&.[](key_type_caster.cast(key))
             end
 
             unless read_only
+              add_method = "add_#{singular_name}" if add_method.nil?
+
               value_type_caster = TypeCaster.new(value_type, values: values)
 
               # Attribute writer
               define_method("#{name}=") do |argument|
-                argument.each { |key, value| send(add_method, key, value) }
+                if argument.nil?
+                  instance_variable_set(instance_variable_name, nil)
+                else
+                  instance_variable_set(instance_variable_name, {})
+                  argument.each { |key, value| send(add_method, key, value) }
+                end
               end
 
               # Add method
@@ -86,6 +99,9 @@ module Jsapi
                 else
                   instance_variable_set(instance_variable_name, {})
                 end[casted_key] = casted_value
+
+                attribute_changed(name)
+                casted_value
               end
             end
           else
@@ -100,9 +116,10 @@ module Jsapi
 
               # Attribute writer
               define_method("#{name}=") do |argument = nil|
-                instance_variable_set(
-                  instance_variable_name, type_caster.cast(argument)
-                )
+                type_caster.cast(argument).tap do |casted_value|
+                  instance_variable_set(instance_variable_name, casted_value)
+                  attribute_changed(name)
+                end
               end
             end
           end

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

@@ -39,6 +39,11 @@ module Jsapi
         def resolve(*)
           self
         end
+
+        protected
+
+        # Invoked whenever an attribute has been changed.
+        def attribute_changed(name); end
       end
     end
   end

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

@@ -24,7 +24,7 @@ module Jsapi
         #
         # Raises a ReferenceError if +ref+ could not be resolved.
         def resolve(definitions)
-          object = definitions.find_component(self.class.component_type, ref)
+          object = definitions.send("find_#{self.class.component_type}", ref)
           raise ReferenceError, ref if object.nil?
 
           object.resolve(definitions)

data/lib/jsapi/meta/definitions.rb

@@ -3,19 +3,29 @@
 module Jsapi
   module Meta
     class Definitions < Base::Model
+      ##
+      # :attr_reader: children
+      # The +Definitions+ instances that directly inherit from this instance.
+      attribute :children, read_only: true, default: []
+
       ##
       # :attr: defaults
       # The Defaults.
       attribute :defaults, { String => Defaults }, keys: Schema::TYPES, default: {}
 
       ##
-      # :attr: included
-      # The Definitions included.
-      attribute :included, [Definitions], default: []
+      # :attr: dependent_definitions
+      # The +Definitions+ instances that directly include this instance.
+      attribute :dependent_definitions, read_only: true, default: []
+
+      ##
+      # :attr: included_definitions
+      # The +Definitions+ instances included.
+      attribute :included_definitions, [Definitions], add_method: :include, default: []
 
       ##
       # :attr: on_rescues
-      # The methods or procs to be called when rescuing an exception.
+      # The methods or procs to be called whenever an exception is rescued.
       attribute :on_rescues, [], default: []
 
       ##
@@ -30,7 +40,7 @@ module Jsapi
 
       ##
       # :attr_reader: owner
-      # The class to which it is assigned.
+      # The class to which this instance is assigned.
       attribute :owner, read_only: true
 
       ##
@@ -40,7 +50,7 @@ module Jsapi
 
       ##
       # :attr_reader: parent
-      # The Definitions from which it inherits.
+      # The +Definitions+ instance from which this instance inherits.
       attribute :parent, read_only: true
 
       ##
@@ -63,24 +73,14 @@ module Jsapi
       # The reusable Schema objects.
       attribute :schemas, { String => Schema }, default: {}
 
-      undef add_included, add_operation, add_parameter
+      undef add_operation, add_parameter, include
 
       def initialize(keywords = {})
         @owner = keywords.delete(:owner)
         @parent = keywords.delete(:parent)
-
         super(keywords)
-      end
-
-      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
+        @parent&.inherited(self)
       end
 
       def add_operation(name = nil, keywords = {}) # :nodoc:
@@ -94,67 +94,79 @@ module Jsapi
         (@parameters ||= {})[name] = Parameter.new(name, keywords)
       end
 
-      # Returns an array containing itself and all of the definitions inherited/included.
+      # Returns an array containing itself and all of the +Definitions+ instances
+      # 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
+        @ancestors ||= [self].tap do |ancestors|
+          (included_definitions + Array(parent)).each do |definitions|
+            ancestors.push(*definitions.ancestors)
           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?
-
-        ancestors.each do |definitions|
-          default = definitions.default(type)
-          return default.value(context: context) if default
-        end
-        nil
-      end
-
-      # 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
+        components.dig(:defaults, type.to_s)&.value(context: context)
       end
 
       # Returns the operation with the specified name.
       def find_operation(name = nil)
-        return find_component(:operation, name) if name.present?
+        return components.dig(:operations, name.to_s) if name.present?
 
         # Return the one and only operation
         operations.values.first if operations.one?
       end
 
+      # Returns the reusable parameter with the specified name.
+      def find_parameter(name)
+        components.dig(:parameters, name&.to_s)
+      end
+
+      # Returns the reusable request body with the specified name.
+      def find_request_body(name)
+        components.dig(:request_bodies, name&.to_s)
+      end
+
+      # Returns the reusable response with the specified name.
+      def find_response(name)
+        components.dig(:responses, name&.to_s)
+      end
+
+      # Returns the reusable schema with the specified name.
+      def find_schema(name)
+        components.dig(:schemas, name&.to_s)
+      end
+
+      # Includes +definitions+.
+      def include(definitions)
+        if circular_dependency?(definitions)
+          raise ArgumentError, 'detected circular dependency between ' \
+                               "#{owner.inspect} and " \
+                               "#{definitions.owner.inspect}"
+        end
+
+        (@included_definitions ||= []) << definitions
+        definitions.included(self)
+        attribute_changed(:included_definitions)
+        self
+      end
+
       def inspect(*attributes) # :nodoc:
-        super(*(attributes.presence || %i[owner parent included]))
+        super(*(attributes.presence || %i[owner]))
       end
 
       # Returns a hash representing the \JSON \Schema document for +name+.
       def json_schema_document(name)
-        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?
+        find_schema(name)&.to_json_schema&.tap do |json_schema_document|
+          if (schemas = components[:schemas].except(name.to_s)).any?
+            json_schema_document[:definitions] = schemas.transform_values(&:to_json_schema)
+          end
         end
       end
 
       # Returns the methods or procs to be called when rescuing an exception.
       def on_rescue_callbacks
-        ancestors.flat_map(&:on_rescues)
+        components[:on_rescues]
       end
 
       # Returns a hash representing the \OpenAPI document for +version+.
@@ -162,79 +174,119 @@ module Jsapi
       # Raises an +ArgumentError+ if +version+ is not supported.
       def openapi_document(version = nil)
         version = OpenAPI::Version.from(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)
+        operations = components[:operations].values
+
+        component_keys = %i[parameters responses parameters schemas]
+        component_keys.insert(3, :request_bodies) if version.major > 2
+
+        openapi_components = component_keys.filter_map do |key|
+          value = components[key].transform_values do |component|
+            case key
+            when :parameters
+              component.to_openapi(version, self).first
+            when :responses
+              component.to_openapi(version, self)
+            else
+              component.to_openapi(version)
+            end
+          end.presence
+
+          [key, value] if value.present?
+        end.to_h
+
+        (openapi&.to_openapi(version, self) || {}).tap do |openapi_document|
+          openapi_document[:paths] =
+            operations
+            .group_by { |operation| operation.path || default_path }
+            .transform_values do |operations_by_path|
+              operations_by_path.index_by(&:method).transform_values do |operation|
+                operation.to_openapi(version, self)
               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
             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?
 
-            h.merge!(openapi_components)
+            openapi_document.merge!(
+              consumes: (consumes.uniq.sort if consumes.present?),
+              produces: (produces.uniq.sort if produces.present?),
+              definitions: openapi_components[:schemas],
+              parameters: openapi_components[:parameters],
+              responses: openapi_components[:responses]
+            )
           elsif openapi_components.any?
-            (h[:components] ||= {}).merge!(openapi_components)
+            (openapi_document[:components] ||= {}).reverse_merge!(
+              openapi_components.transform_keys do |key|
+                key.to_s.camelize(:lower).to_sym
+              end
+            )
           end
         end.compact
       end
 
       # Returns the first RescueHandler to handle +exception+, or nil if no one could be found.
       def rescue_handler_for(exception)
-        ancestors.each do |definitions|
-          definitions.rescue_handlers.each do |rescue_handler|
-            return rescue_handler if rescue_handler.match?(exception)
-          end
+        components[:rescue_handlers].find { |r| r.match?(exception) }
+      end
+
+      protected
+
+      def attribute_changed(name) # :nodoc:
+        return if name == :openapi
+
+        if name == :included_definitions
+          invalidate_ancestors
+        else
+          invalidate_components
         end
-        nil
+      end
+
+      # Invoked whenever it is included in another +Definitions+ instance.
+      def included(definitions)
+        (@dependent_definitions ||= []) << definitions
+      end
+
+      # rubocop:disable Lint/MissingSuper
+
+      # Invoked whenever it is inherited by another +Definitions+ instance.
+      def inherited(definitions)
+        (@children ||= []) << definitions
+      end
+
+      # rubocop:enable Lint/MissingSuper
+
+      # Invalidates cached ancestors.
+      def invalidate_ancestors
+        @ancestors = nil
+        @components = nil
+        (children + dependent_definitions).each(&:invalidate_ancestors)
+      end
+
+      # Invalidates cached components.
+      def invalidate_components
+        @components = nil
+        (children + dependent_definitions).each(&:invalidate_components)
       end
 
       private
 
       def circular_dependency?(other)
         return true if other == self
-        return false if other.included.none?
+        return false if other.included_definitions.none?
+
+        other.included_definitions.any? { |included| circular_dependency?(included) }
+      end
 
-        other.included.any? { |included| circular_dependency?(included) }
+      def components
+        @components ||= ancestors.each_with_object({}) do |ancestor, components|
+          %i[defaults operations parameters request_bodies responses schemas].each do |type|
+            (components[type] ||= {}).reverse_merge!(ancestor.send(type))
+          end
+          %i[on_rescues rescue_handlers].each do |type|
+            (components[type] ||= []).push(*ancestor.send(type))
+          end
+        end
       end
 
       def default_operation_name

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

@@ -6,11 +6,8 @@ module Jsapi
   module Meta
     module Schema
       module Conversion
-        extend ActiveSupport::Concern
-
-        included do
-          # The method or +Proc+ to convert objects by.
-          attr_accessor :conversion
+        def self.included(mod)
+          mod.attr_accessor :conversion
         end
 
         def convert(object)

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

@@ -68,7 +68,7 @@ module Jsapi
           value = property.default_value(definitions, context: context) if value.nil?
           raise "#{discriminator.property_name} can't be nil" if value.nil?
 
-          schema = definitions.find_component(:schema, discriminator.mapping(value) || value)
+          schema = definitions.find_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/model/attributes.rb

@@ -3,10 +3,8 @@
 module Jsapi
   module Model
     module Attributes
-      extend ActiveSupport::Concern
-
-      included do
-        delegate :[], :additional_attributes, :attribute?, :attributes, to: :nested
+      def self.included(mod)
+        mod.delegate :[], :additional_attributes, :attribute?, :attributes, to: :nested
       end
 
       def method_missing(*args) # :nodoc:

data/lib/jsapi/model/base.rb

@@ -6,9 +6,10 @@ module Jsapi
     # parameters by default.
     class Base
       extend Naming
-
       include Attributes
-      include Validations
+      include ActiveModel::Validations
+
+      validate :nested_validity
 
       def initialize(nested)
         @nested = nested
@@ -21,6 +22,12 @@ module Jsapi
         )
       end
 
+      # Overrides <code>ActiveModel::Validations#errors</code>
+      # to use Errors as error store.
+      def errors
+        @errors ||= Errors.new(self)
+      end
+
       def inspect # :nodoc:
         "#<#{self.class.name}#{' ' if attributes.any?}" \
         "#{attributes.map { |k, v| "#{k}: #{v.inspect}" }.join(', ')}>"
@@ -29,6 +36,10 @@ module Jsapi
       private
 
       attr_reader :nested
+
+      def nested_validity
+        @nested.validate(errors)
+      end
     end
   end
 end

data/lib/jsapi/model.rb

@@ -5,11 +5,10 @@ require_relative 'model/nested_error'
 require_relative 'model/errors'
 require_relative 'model/attributes'
 require_relative 'model/naming'
-require_relative 'model/validations'
 require_relative 'model/base'
 require_relative 'model/nestable'
 
 module Jsapi
-  # Provides classes and modules to deal with API models.
+  # Provides classes to deal with API models.
   module Model end
 end

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.7.0'
+    VERSION = '0.7.2'
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: jsapi
 version: !ruby/object:Gem::Version
-  version: 0.7.0
+  version: 0.7.2
 platform: ruby
 authors:
 - Denis Göller
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-09-21 00:00:00.000000000 Z
+date: 2024-09-24 00:00:00.000000000 Z
 dependencies: []
 description: Jsapi can be used to read requests, produce responses and create OpenAPI
   documents
@@ -145,7 +145,6 @@ files:
 - lib/jsapi/model/naming.rb
 - lib/jsapi/model/nestable.rb
 - lib/jsapi/model/nested_error.rb
-- lib/jsapi/model/validations.rb
 - lib/jsapi/version.rb
 homepage: https://github.com/dmgoeller/jsapi
 licenses:

data/lib/jsapi/model/validations.rb

@@ -1,27 +0,0 @@
-# frozen_string_literal: true
-
-module Jsapi
-  module Model
-    module Validations
-      extend ActiveSupport::Concern
-
-      include ActiveModel::Validations
-
-      included do
-        validate :nested_validity
-      end
-
-      # Overrides <code>ActiveModel::Validations#errors</code>
-      # to use Errors as error store.
-      def errors
-        @errors ||= Errors.new(self)
-      end
-
-      private
-
-      def nested_validity
-        nested.validate(errors)
-      end
-    end
-  end
-end