jsapi 0.7.3 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f0b8caebf611ba584ebd5963fefb3e7f4600f3cdda59eeda99049225f4a17fff
-  data.tar.gz: 94db4048e68964bc70e64068631a3ae01b9ef7434fab23976e69b6368f809d37
+  metadata.gz: 41bcc8f72dc668c6df55dfc73e6e2c9cc6fde569ebe008e503586100e0b3bba1
+  data.tar.gz: 9667a2661824e0d3a47675e835f3372cfd22bff71ab8c7bb3bde3c0e56cc78be
 SHA512:
-  metadata.gz: 144e852da54524999df466dbdf078227cae7d5e68d3155fbc3730b298072d696a39cea1c786513c34862bcb71a14b163bd202b9c203e4736598cb0fddc28813b
-  data.tar.gz: 9d76e40aa500597eec1a5a7dc02b794ccde643f603227455ccbcea76a6e074769c246335a1e554fa19bc6d06cf8cf36ad030147a651de58f148b3c4db5c12322
+  metadata.gz: 576422bac22ee56e77ab160e50033a78ba1f02039fd5a7686583d0778f049e331892bb5d7692dcdc428c9b250706f13bf6e585db4472d40e31d63537116d9f37
+  data.tar.gz: e3ef8964a2a55d6f245a8982e7dcad76f564d066af119eec43edb1b5bc579f1771ce87e747924e5cd2d6b650e07e44515ff7e722860a4c4ee8c6fa7e8b0360cb

data/lib/jsapi/controller/{error_result.rb → error.rb}

@@ -3,7 +3,7 @@
 module Jsapi
   module Controller
     # Used by Methods#api_operation! to produce an error response.
-    class ErrorResult
+    class Error
       delegate_missing_to :@exception
 
       # The HTTP status code of the error response to be produced.

data/lib/jsapi/controller/methods.rb

@@ -27,14 +27,18 @@ module Jsapi
       # that the model passed to the block is invalid if there are any request parameters
       # that can't be mapped to a parameter or a request body property of the operation.
       #
-      # The +:omit+ option specifies on which conditions properties are omitted.
+      # The +:omit+ option specifies on which conditions properties are omitted in responses.
       # Possible values are:
       #
       # - +:empty+ - All of the  properties whose value is empty are omitted.
       # - +:nil+ - All of the properties whose value is +nil+ are omitted.
       #
-      # Raises an InvalidArgumentError when the value of +:omit+ is invalid.
-      def api_operation(operation_name = nil, omit: nil, status: nil, strong: false, &block)
+      # Raises an +ArgumentError+ when +:omit+ is other than +:empty+, +:nil+ or +nil+.
+      def api_operation(operation_name = nil,
+                        omit: nil,
+                        status: nil,
+                        strong: false,
+                        &block)
         _api_operation(
           operation_name,
           bang: false,
@@ -52,7 +56,11 @@ module Jsapi
       #     # ...
       #   end
       #
-      def api_operation!(operation_name = nil, omit: nil, status: nil, strong: false, &block)
+      def api_operation!(operation_name = nil,
+                         omit: nil,
+                         status: nil,
+                         strong: false,
+                         &block)
         _api_operation(
           operation_name,
           bang: true,
@@ -97,13 +105,13 @@ module Jsapi
       # - +:empty+ - All of the  properties whose value is empty are omitted.
       # - +:nil+ - All of the properties whose value is +nil+ are omitted.
       #
-      # Raises an InvalidArgumentError when the value of +:omit+ is invalid.
+      # Raises an +ArgumentError+ when +:omit+ is other than +:empty+, +:nil+ or +nil+.
       def api_response(result, operation_name = nil, omit: nil, status: nil)
         definitions = api_definitions
         operation = _find_api_operation(operation_name, definitions)
-        response = _api_response(operation, status, definitions)
+        response_model = _api_response(operation, status, definitions)
 
-        Response.new(result, response, api_definitions, omit: omit)
+        Response.new(result, response_model, api_definitions, omit: omit)
       end
 
       private
@@ -111,40 +119,43 @@ module Jsapi
       def _api_operation(operation_name, bang:, omit:, status:, strong:, &block)
         definitions = api_definitions
         operation = _find_api_operation(operation_name, definitions)
-        response = _api_response(operation, status, definitions)
-
-        if block
-          params = _api_params(operation, definitions, strong: strong)
-          result = begin
-            raise ParametersInvalid.new(params) if bang && params.invalid?
-
-            block.call(params)
-          rescue StandardError => e
-            # Lookup a rescue handler
-            rescue_handler = definitions.rescue_handler_for(e)
-            raise e if rescue_handler.nil?
-
-            # Change the HTTP status code and response schema
-            status = rescue_handler.status
-            response = operation.response(status)&.resolve(definitions)
-            raise e if response.nil?
-
-            # Call on_rescue callbacks
-            definitions.on_rescue_callbacks.each do |callback|
-              if callback.respond_to?(:call)
-                callback.call(e)
-              else
-                send(callback, e)
-              end
-            end
 
-            ErrorResult.new(e, status: status)
+        # Perform operation
+        response_model = _api_response(operation, status, definitions)
+        head(status) && return unless block
+
+        params = _api_params(operation, definitions, strong: strong)
+
+        result = begin
+          raise ParametersInvalid.new(params) if bang && params.invalid?
+
+          block.call(params)
+        rescue StandardError => e
+          # Lookup a rescue handler
+          rescue_handler = definitions.rescue_handler_for(e)
+          raise e if rescue_handler.nil?
+
+          # Change the HTTP status code and response model
+          status = rescue_handler.status
+          response_model = operation.response(status)&.resolve(definitions)
+          raise e if response_model.nil?
+
+          # Call on_rescue callbacks
+          definitions.on_rescue_callbacks.each do |callback|
+            if callback.respond_to?(:call)
+              callback.call(e)
+            else
+              send(callback, e)
+            end
           end
-          render(json: Response.new(result, response, definitions, omit: omit), status: status)
-        else
-          head(status)
+
+          Error.new(e, status: status)
         end
-        self.content_type = response.content_type
+        response = Response.new(result, response_model, definitions, omit: omit)
+
+        # Write response
+        self.content_type = response_model.content_type
+        render(json: response, status: status)
       end
 
       def _api_params(operation, definitions, strong:)

data/lib/jsapi/controller/parameters.rb

@@ -27,7 +27,8 @@ module Jsapi
           @raw_attributes[name] = JSON.wrap(
             parameter_model.in == 'header' ? headers[name] : @params[name],
             parameter_model.schema.resolve(definitions),
-            definitions
+            definitions,
+            context: :request
           )
         end
 
@@ -38,7 +39,8 @@ module Jsapi
           request_body = JSON.wrap(
             @params.except(*operation.parameters.keys),
             request_body_schema,
-            definitions
+            definitions,
+            context: :request
           )
           @raw_attributes.merge!(request_body.raw_attributes)
           @raw_additional_attributes = request_body.raw_additional_attributes

data/lib/jsapi/controller/response.rb

@@ -2,10 +2,20 @@
 
 module Jsapi
   module Controller
-    # Used to serialize a response.
+    # Used to jsonify a response.
     class Response
+      class JsonifyError < RuntimeError # :nodoc:
+        def message
+          [@path&.delete_prefix('.') || 'response body', super].join(' ')
+        end
+
+        def prepend(origin)
+          @path = "#{origin}#{@path}"
+          self
+        end
+      end
 
-      # Creates a new instance to serialize +object+ according to +response+. References
+      # Creates a new instance to jsonify +object+ according to +response+. References
       # are resolved to API components in +definitions+.
       #
       # The +:omit+ option specifies on which conditions properties are omitted.
@@ -14,111 +24,119 @@ module Jsapi
       # - +:empty+ - All of the  properties whose value is empty are omitted.
       # - +:nil+ - All of the properties whose value is +nil+ are omitted.
       #
-      # Raises an InvalidArgumentError when the value of +:omit+ is invalid.
+      # Raises an +ArgumentError+ when +:omit+ is other than +:empty+, +:nil+ or +nil+.
       def initialize(object, response, definitions, omit: nil)
-        if [:empty, :nil, nil].exclude?(omit)
-          raise InvalidArgumentError.new('omit', omit, valid_values: %i[empty nil])
-        end
-
         @object = object
         @response = response
         @definitions = definitions
-        @omit = omit
+
+        @omittable_check =
+          case omit
+          when nil
+            nil
+          when :nil
+            ->(value, schema) { schema.omittable? && value.nil? }
+          when :empty
+            ->(value, schema) { schema.omittable? && value.try(:empty?) }
+          else
+            raise InvalidArgumentError.new('omit', omit, valid_values: %i[empty nil])
+          end
       end
 
       def inspect # :nodoc:
         "#<#{self.class.name} #{@object.inspect}>"
       end
 
-      # Returns the JSON representation of the response as a +String+.
+      # Returns the \JSON representation of the response as a string.
       def to_json(*)
         schema = @response.schema.resolve(@definitions)
         if @response.locale
-          I18n.with_locale(@response.locale) do
-            serialize(@object, schema)
-          end
+          I18n.with_locale(@response.locale) { jsonify(@object, schema) }
         else
-          serialize(@object, schema)
+          jsonify(@object, schema)
         end.to_json
       end
 
       private
 
-      def serialize(object, schema, path = nil)
+      def jsonify(object, schema)
         object = schema.default_value(@definitions, context: :response) if object.nil?
-        return if object.nil? && schema.nullable?
-
-        raise "#{path || 'response'} can't be nil" if object.nil?
-
-        case schema.type
-        when 'array'
-          serialize_array(object, schema, path)
-        when 'integer'
-          schema.convert(object.to_i)
-        when 'number'
-          schema.convert(object.to_f)
-        when 'object'
-          serialize_object(object, schema, path)
-        when 'string'
-          schema.convert(
-            case schema.format
-            when 'date'
-              object.to_date
-            when 'date-time'
-              object.to_datetime
-            when 'duration'
-              object.iso8601
-            else
-              object.to_s
-            end
-          )
+
+        if object.nil?
+          raise JsonifyError, "can't be nil" unless schema.nullable?
         else
-          object
+          case schema.type
+          when 'array'
+            jsonify_array(object, schema)
+          when 'boolean'
+            object
+          when 'integer'
+            schema.convert(object.to_i)
+          when 'number'
+            schema.convert(object.to_f)
+          when 'object'
+            jsonify_object(object, schema)
+          when 'string'
+            schema.convert(
+              case schema.format
+              when 'date'
+                object.to_date
+              when 'date-time'
+                object.to_datetime
+              when 'duration'
+                object.iso8601
+              else
+                object.to_s
+              end
+            )
+          else
+            raise JsonifyError, "has an invalid type: #{schema.type.inspect}"
+          end
         end
       end
 
-      def serialize_array(array, schema, path)
+      def jsonify_array(array, schema)
         item_schema = schema.items.resolve(@definitions)
-        Array(array).map { |item| serialize(item, item_schema, path) }
+        index = 0
+
+        Array(array).map do |item|
+          item = jsonify(item, item_schema)
+          index += 1
+          item
+        rescue JsonifyError => e
+          raise e.prepend("[#{index}]")
+        end
       end
 
-      def serialize_object(object, schema, path)
+      def jsonify_object(object, schema)
         schema = schema.resolve_schema(object, @definitions, context: :response)
         properties = {}
 
-        # Serialize properties
-        schema.resolve_properties(@definitions, context: :response).each do |key, property|
+        # Add properties
+        schema.resolve_properties(@definitions, context: :response).each_value do |property|
           property_schema = property.schema.resolve(@definitions)
           property_value = property.reader.call(object)
           property_value = property_schema.default if property_value.nil?
+          next if @omittable_check&.call(property_value, property_schema)
 
-          next if ((@omit == :empty && property_value.try(:empty?)) ||
-                   (@omit == :nil && property_value.nil?)) &&
-                  property_schema.omittable?
-
-          properties[key] = serialize(
-            property_value,
-            property_schema,
-            path.nil? ? property.name : "#{path}.#{property.name}"
-          )
+          properties[property.name] = jsonify(property_value, property_schema)
+        rescue JsonifyError => e
+          raise e.prepend(".#{property.name}")
         end
-        # Serialize additional properties
+        # Add additional properties
         if (additional_properties = schema.additional_properties)
           additional_properties_schema = additional_properties.schema.resolve(@definitions)
 
           additional_properties.source.call(object)&.each do |key, value|
-            # Don't replace the property with the same key
             next if properties.key?(key = key.to_s)
 
-            properties[key] = serialize(
-              value,
-              additional_properties_schema,
-              path.nil? ? key : "#{path}.#{key}"
-            )
+            properties[key] = jsonify(value, additional_properties_schema)
+          rescue JsonifyError => e
+            raise e.prepend(".#{key}")
           end
         end
-        # Return properties if present, otherwise nil
-        properties if properties.present?
+
+        properties.presence
       end
     end
   end

data/lib/jsapi/controller.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 require_relative 'controller/parameters_invalid'
-require_relative 'controller/error_result'
+require_relative 'controller/error'
 require_relative 'controller/parameters'
 require_relative 'controller/response'
 require_relative 'controller/methods'

data/lib/jsapi/{helpers/invalid_value_helper.rb → invalid_value_helper.rb}

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Jsapi
-  module InvalidValueHelper
+  module InvalidValueHelper # :nodoc:
     def build_message(name, value, valid_values)
       case valid_values.count
       when 0

data/lib/jsapi/json/array.rb

@@ -4,30 +4,30 @@ module Jsapi
   module JSON
     # Represents a JSON array.
     class Array < Value
-      def initialize(elements, schema, definitions)
+      def initialize(array, schema, definitions, context: nil)
         super(schema)
-        @elements = Array(elements).map do |element|
-          JSON.wrap(element, schema.items, definitions)
+        @json_values = Array(array).map do |item|
+          JSON.wrap(item, schema.items, definitions, context: context)
         end
       end
 
       # Returns true if it contains no elements, false otherwise.
       def empty?
-        @elements.empty?
+        @json_values.empty?
       end
 
       def inspect # :nodoc:
-        "#<#{self.class.name} [#{@elements.map(&:inspect).join(', ')}]>"
+        "#<#{self.class.name} [#{@json_values.map(&:inspect).join(', ')}]>"
       end
 
       def validate(errors) # :nodoc:
         return false unless super
 
-        @elements.map { |element| element.validate(errors) }.all?
+        @json_values.map { |element| element.validate(errors) }.all?
       end
 
       def value
-        @value ||= @elements.map(&:value)
+        @value ||= @json_values.map(&:value)
       end
     end
   end

data/lib/jsapi/json/object.rb

@@ -8,20 +8,20 @@ module Jsapi
 
       attr_reader :raw_additional_attributes, :raw_attributes
 
-      def initialize(attributes, schema, definitions)
-        schema = schema.resolve_schema(attributes, definitions, context: :request)
-        properties = schema.resolve_properties(definitions, context: :request)
+      def initialize(hash, schema, definitions, context: nil)
+        schema = schema.resolve_schema(hash, definitions, context: context)
+        properties = schema.resolve_properties(definitions, context: context)
 
         @raw_attributes = properties.transform_values do |property|
-          JSON.wrap(attributes[property.name], property.schema, definitions)
+          JSON.wrap(hash[property.name], property.schema, definitions, context: context)
         end
 
         @raw_additional_attributes =
           if (additional_properties = schema.additional_properties)
             additional_properties_schema = additional_properties.schema.resolve(definitions)
 
-            attributes.except(*properties.keys).transform_values do |value|
-              JSON.wrap(value, additional_properties_schema, definitions)
+            hash.except(*properties.keys).transform_values do |value|
+              JSON.wrap(value, additional_properties_schema, definitions, context: context)
             end
           end || {}
 

data/lib/jsapi/json.rb

@@ -13,15 +13,15 @@ module Jsapi
   # Provides a DOM for JSON values.
   module JSON
     class << self
-      def wrap(object, schema, definitions = nil)
+      def wrap(object, schema, definitions = nil, context: nil)
         schema = schema.resolve(definitions) unless definitions.nil?
 
-        object = schema.default_value(definitions, context: :request) if object.nil?
+        object = schema.default_value(definitions, context: context) if object.nil?
         return Null.new(schema) if object.nil?
 
         case schema.type
         when 'array'
-          Array.new(object, schema, definitions)
+          Array.new(object, schema, definitions, context: context)
         when 'boolean'
           Boolean.new(object, schema)
         when 'integer'
@@ -29,7 +29,7 @@ module Jsapi
         when 'number'
           Number.new(object, schema)
         when 'object'
-          Object.new(object, schema, definitions)
+          Object.new(object, schema, definitions, context: context)
         when 'string'
           String.new(object, schema)
         else

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.3'
+    VERSION = '0.8.0'
   end
 end

data/lib/jsapi.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'jsapi/helpers/invalid_value_helper'
+require 'jsapi/invalid_value_helper'
 require 'jsapi/invalid_value_error'
 require 'jsapi/invalid_argument_error'
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: jsapi
 version: !ruby/object:Gem::Version
-  version: 0.7.3
+  version: 0.8.0
 platform: ruby
 authors:
 - Denis Göller
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-09-25 00:00:00.000000000 Z
+date: 2024-09-29 00:00:00.000000000 Z
 dependencies: []
 description: Jsapi can be used to read requests, produce responses and create OpenAPI
   documents
@@ -20,7 +20,7 @@ files:
 - lib/jsapi.rb
 - lib/jsapi/controller.rb
 - lib/jsapi/controller/base.rb
-- lib/jsapi/controller/error_result.rb
+- lib/jsapi/controller/error.rb
 - lib/jsapi/controller/methods.rb
 - lib/jsapi/controller/parameters.rb
 - lib/jsapi/controller/parameters_invalid.rb
@@ -40,9 +40,9 @@ files:
 - lib/jsapi/dsl/request_body.rb
 - lib/jsapi/dsl/response.rb
 - lib/jsapi/dsl/schema.rb
-- lib/jsapi/helpers/invalid_value_helper.rb
 - lib/jsapi/invalid_argument_error.rb
 - lib/jsapi/invalid_value_error.rb
+- lib/jsapi/invalid_value_helper.rb
 - lib/jsapi/json.rb
 - lib/jsapi/json/array.rb
 - lib/jsapi/json/boolean.rb