media_types-serialization 1.0.2 → 1.3.0

data/lib/media_types/serialization.rb

@@ -15,8 +15,7 @@ require 'active_support/concern'
 require 'active_support/core_ext/module/attribute_accessors'
 require 'active_support/core_ext/object/blank'
 
-require 'http_headers/accept'
-
+require 'media_types/serialization/utils/accept_header'
 require 'media_types/serialization/base'
 require 'media_types/serialization/error'
 require 'media_types/serialization/serialization_dsl'
@@ -44,7 +43,8 @@ end
 module MediaTypes
   module Serialization
 
-    HEADER_ACCEPT = 'HTTP_ACCEPT'
+    HEADER_ACCEPT = 'HTTP_ACCEPT'.freeze
+    HEADER_ACCEPT_LANGUAGE = 'HTTP_ACCEPT_LANGUAGE'.freeze
 
     mattr_accessor :json_encoder, :json_decoder
     if defined?(::Oj)
@@ -183,7 +183,60 @@ module MediaTypes
           @serialization_output_registrations = @serialization_output_registrations.merge(mergeable_outputs)
         end
       end
-      
+
+      def allow_output_html(as: nil, view: nil, layout: nil, formats: [:html], variants: nil, **filter_opts)
+        before_action(**filter_opts) do
+          raise SerializersAlreadyFrozenError if defined? @serialization_frozen
+
+          @serialization_output_registrations ||= SerializationRegistration.new(:output)
+
+          html_registration = SerializationRegistration.new(:output)
+          output_identifier = 'text/html'
+          output_identifier += "; variant=#{as}" unless as.nil?
+
+          validator = FakeValidator.new(as.nil? ? 'text/html' : as)
+
+          block = lambda { |_, _, controller|
+            options = {}
+            options[:layout] = layout unless layout.nil?
+            options[:template] = view unless view.nil?
+            options[:formats] = formats unless formats.nil?
+            options[:variants] = variants unless variants.nil?
+
+            controller.render_to_string(**options)
+          }
+
+          html_registration.register_block(nil, validator, nil, block, true, wildcards: true)
+          html_registration.registrations[validator.identifier].display_identifier = output_identifier
+          html_registration.registrations["#{validator.identifier.split('/')[0]}/*"].display_identifier = output_identifier
+          html_registration.registrations['*/*'].display_identifier = output_identifier
+
+          @serialization_output_registrations = @serialization_output_registrations.merge(html_registration)
+        end
+      end
+
+      def allow_output_docs(description, **filter_opts)
+        before_action(**filter_opts) do
+          raise SerializersAlreadyFrozenError if defined? @serialization_frozen
+
+          @serialization_output_registrations ||= SerializationRegistration.new(:output)
+
+          docs_registration = SerializationRegistration.new(:output)
+          validator = FakeValidator.new('text/vnd.delftsolutions.docs')
+
+          block = lambda { |_, _, _|
+            description
+          }
+
+          docs_registration.register_block(nil, validator, nil, block, true, wildcards: true)
+          docs_registration.registrations['text/vnd.delftsolutions.docs'].display_identifier = 'text/plain; charset=utf-8'
+          docs_registration.registrations['text/*'].display_identifier = 'text/plain; charset=utf-8'
+          docs_registration.registrations['*/*'].display_identifier = 'text/plain; charset=utf-8'
+
+          @serialization_output_registrations = @serialization_output_registrations.merge(docs_registration)
+        end
+      end
+
       def allow_api_viewer(serializer: MediaTypes::Serialization::Serializers::ApiViewer, **filter_opts)
         before_action do
           @serialization_api_viewer_enabled ||= {}
@@ -216,7 +269,7 @@ module MediaTypes
         raise ArrayInViewParameterError, :allow_input_serializer if view.is_a? Array
         views = [view] if views.nil?
         raise ViewsNotAnArrayError unless views.is_a? Array
-        
+
         before_action do
           @serialization_available_serializers ||= {}
           @serialization_available_serializers[:input] ||= {}
@@ -259,8 +312,8 @@ module MediaTypes
       ##
       # Freezes additions to the serializes and notifies the controller what it will be able to respond to.
       #
-      def freeze_io!
-        before_action :serializer_freeze_io_internal
+      def freeze_io!(**filter_opts)
+        before_action :serializer_freeze_io_internal, **filter_opts
 
         output_error MediaTypes::Serialization::NoInputReceivedError do |p, error|
           p.title 'Providing input is mandatory. Please set a Content-Type', lang: 'en'
@@ -283,11 +336,6 @@ module MediaTypes
     end
     # rubocop:enable Metrics/BlockLength
 
-    included do
-      protected
-
-    end
-
     protected
 
     def serialize(victim, media_type, serializer: Object.new, links: [], vary: ['Accept'])
@@ -307,6 +355,7 @@ module MediaTypes
       if obj == MEDIA_TYPES_SERIALIZATION_OBJ_IS_UNDEFINED && block.nil?
         raise 'render_media was called without an object. Please provide one or supply a block to match the serializer.'
       end
+
       obj = nil if obj == MEDIA_TYPES_SERIALIZATION_OBJ_IS_UNDEFINED
 
       raise SerializersNotFrozenError unless defined? @serialization_frozen
@@ -336,10 +385,17 @@ module MediaTypes
         selector.instance_exec(&block)
 
         raise UnmatchedSerializerError, serializer unless selector.matched
+
         obj = selector.value
       end
 
-      serialization_render_resolved(obj: obj, serializer: serializer, identifier: identifier, registrations: registration, options: options)
+      serialization_render_resolved(
+        obj: obj,
+        serializer: serializer,
+        identifier: identifier,
+        registrations: registration,
+        options: options
+      )
     end
 
     def deserialize(request)
@@ -358,6 +414,7 @@ module MediaTypes
       raise SerializersNotFrozenError unless defined?(@serialization_frozen)
       raise NoInputReceivedError if request.content_type.blank?
       raise InputNotAcceptableError unless @serialization_input_registrations.has? request.content_type
+
       @serialization_input_registrations.call(@serialization_decoded_input, request.content_type, self)
     end
 
@@ -366,8 +423,9 @@ module MediaTypes
       return nil if identifier.nil?
 
       registration = registration.registrations[identifier]
-      
+
       raise 'Assertion failed, inconsistent answer from resolve_media_type' if registration.nil?
+
       registration.serializer
     end
 
@@ -375,8 +433,12 @@ module MediaTypes
 
     def resolve_media_type(request, registration, allow_last: true)
       if defined? @serialization_override_accept
-        @serialization_override_accept = registration.registrations.keys.last if allow_last && @serialization_override_accept == 'last'
+        if allow_last && @serialization_override_accept == 'last'
+          @serialization_override_accept = registration.registrations.keys.last
+        end
+
         return nil unless registration.has? @serialization_override_accept
+
         return @serialization_override_accept
       end
 
@@ -386,7 +448,7 @@ module MediaTypes
       #
       #
 
-      accept_header = HttpHeaders::Accept.new(request.get_header(HEADER_ACCEPT)) || ''
+      accept_header = Utils::AcceptHeader.new(request.get_header(HEADER_ACCEPT)) || ''
       accept_header.each do |mime_type|
         stripped = mime_type.to_s.split(';')[0]
         next unless registration.has? stripped
@@ -403,7 +465,7 @@ module MediaTypes
       identifier = serializer.validator.identifier
       obj = { request: request, registrations: registrations }
       new_registrations = serializer.outputs_for(views: [nil])
-    
+
       serialization_render_resolved(obj: obj, serializer: serializer, identifier: identifier, registrations: new_registrations, options: {})
       response.status = :not_acceptable
     end
@@ -424,7 +486,10 @@ module MediaTypes
       input_is_allowed = @serialization_input_registrations.has? request.content_type unless request.content_type.blank?
 
       unless input_is_allowed || all_allowed
-        serializers = @serialization_unsupported_media_type_serializer || [MediaTypes::Serialization::Serializers::ProblemSerializer, MediaTypes::Serialization::Serializers::FallbackUnsupportedMediaTypeSerializer]
+        serializers = @serialization_unsupported_media_type_serializer || [
+          MediaTypes::Serialization::Serializers::ProblemSerializer,
+          MediaTypes::Serialization::Serializers::FallbackUnsupportedMediaTypeSerializer
+        ]
         registrations = SerializationRegistration.new(:output)
         serializers.each do |s|
           registrations = registrations.merge(s.outputs_for(views: [nil, :html]))
@@ -452,7 +517,10 @@ module MediaTypes
           input_data = request.body.read
           @serialization_decoded_input = @serialization_input_registrations.decode(input_data, request.content_type, self)
         rescue InputValidationFailedError => e
-          serializers = @serialization_input_validation_failed_serializer || [MediaTypes::Serialization::Serializers::ProblemSerializer, MediaTypes::Serialization::Serializers::InputValidationErrorSerializer]
+          serializers = @serialization_input_validation_failed_serializer || [
+            MediaTypes::Serialization::Serializers::ProblemSerializer,
+            MediaTypes::Serialization::Serializers::InputValidationErrorSerializer
+          ]
           registrations = SerializationRegistration.new(:output)
           serializers.each do |s|
             registrations = registrations.merge(s.outputs_for(views: [nil, :html]))
@@ -498,7 +566,13 @@ module MediaTypes
           actions: @serialization_available_serializers,
         }
 
-        serialization_render_resolved obj: input, serializer: description_serializer, identifier: endpoint_matched_identifier, registrations: @serialization_output_registrations, options: {}
+        serialization_render_resolved(
+          obj: input,
+          serializer: description_serializer,
+          identifier: endpoint_matched_identifier,
+          registrations: @serialization_output_registrations,
+          options: {}
+        )
         return
       end
 

data/lib/media_types/serialization/base.rb

@@ -30,6 +30,10 @@ module MediaTypes
           self.serializer_disable_wildcards = true
         end
 
+        def enable_wildcards
+          self.serializer_disable_wildcards = false
+        end
+
         def output(view: nil, version: nil, versions: nil, &block)
           versions = [version] if versions.nil?
           raise VersionsNotAnArrayError unless versions.is_a? Array
@@ -57,18 +61,18 @@ module MediaTypes
           end
         end
 
-        def output_alias(media_type_identifier, view: nil)
+        def output_alias(media_type_identifier, view: nil, hide_variant: false)
           validator = serializer_validator.view(view)
           victim_identifier = validator.identifier
 
-          serializer_output_registration.register_alias(self, media_type_identifier, victim_identifier, false, wildcards: !self.serializer_disable_wildcards)
+          serializer_output_registration.register_alias(self, media_type_identifier, victim_identifier, false, hide_variant, wildcards: !self.serializer_disable_wildcards)
         end
 
-        def output_alias_optional(media_type_identifier, view: nil)
+        def output_alias_optional(media_type_identifier, view: nil, hide_variant: false)
           validator = serializer_validator.view(view)
           victim_identifier = validator.identifier
 
-          serializer_output_registration.register_alias(self, media_type_identifier, victim_identifier, true, wildcards: !self.serializer_disable_wildcards)
+          serializer_output_registration.register_alias(self, media_type_identifier, victim_identifier, true, hide_variant, wildcards: !self.serializer_disable_wildcards)
         end
 
         def input(view: nil, version: nil, versions: nil, &block)
@@ -102,22 +106,22 @@ module MediaTypes
           validator = serializer_validator.view(view)
           victim_identifier = validator.identifier
 
-          serializer_input_registration.register_alias(self, media_type_identifier, victim_identifier, false)
+          serializer_input_registration.register_alias(self, media_type_identifier, victim_identifier, false, true, wildcards: false)
         end
 
         def input_alias_optional(media_type_identifier, view: nil)
           validator = serializer_validator.view(view)
           victim_identifier = validator.identifier
 
-          serializer_input_registration.register_alias(self, media_type_identifier, victim_identifier, true)
+          serializer_input_registration.register_alias(self, media_type_identifier, victim_identifier, true, true, wildcards: false)
         end
 
-        def serialize(victim, media_type_identifier, context, dsl: nil, raw: nil)
+        def serialize(victim, media_type_identifier, context:, dsl: nil, raw: nil)
           dsl ||= SerializationDSL.new(self, context: context)
           serializer_output_registration.call(victim, media_type_identifier.to_s, context, dsl: dsl, raw: raw)
         end
 
-        def deserialize(victim, media_type_identifier, context)
+        def deserialize(victim, media_type_identifier, context:)
           serializer_input_registration.call(victim, media_type_identifier, context)
         end
 

data/lib/media_types/serialization/error.rb

@@ -73,21 +73,29 @@ module MediaTypes
       def initialize(identifier, inout)
         super(
             "Serializer tried to define an #{inout}_alias that points to the media type identifier #{identifier} but no such #{inout} has been defined yet. Please move the #{inout} definition above the alias.\n\n" \
-            "Move the output definition above the alias:\n" \
+            "Move the #{inout} definition above the alias:\n" \
             "\n" \
             "class MySerializer < MediaTypes::Serialization::Base\n" \
             "#...\n" \
-            "output do\n" \
+            "#{inout} do\n" \
             "  # ...\n" \
             "end\n" \
             "\n" \
-            "output_alias 'text/html'\n" \
+            "#{inout}_alias 'text/html'\n" \
             "# ^----- move here\n" \
             'end'
         )
       end
     end
 
+    class VersionedAliasDefinitionError < ConfigurationError
+      def initialize(identifier, inout, prefix_match)
+        super(
+          "Serializer tried to define an #{inout}_alias that points to the media type identifier #{identifier} but no such #{inout} has been defined yet. An #{inout} named #{prefix_match} was found. Often this can be fixed by providing an #{inout} with a nil version."
+        )
+      end
+    end
+
     class DuplicateDefinitionError < ConfigurationError
       def initialize(identifier, inout)
         super("Serializer tried to define an #{inout} using the media type identifier #{identifier}, but another #{inout} was already defined with that identifier. Please remove one of the two.")

data/lib/media_types/serialization/fake_validator.rb

@@ -27,8 +27,8 @@ class FakeValidator
   def identifier
     suffix = suffixes[[internal_view, internal_version]] || ''
     result = prefix
-    result += '.' + internal_view.to_s unless internal_view.nil?
     result += '.v' + internal_version.to_s unless internal_version.nil?
+    result += '.' + internal_view.to_s unless internal_view.nil?
     result += '+' + suffix.to_s unless suffix.empty?
 
     result

data/lib/media_types/serialization/serialization_dsl.rb

@@ -56,7 +56,7 @@ module MediaTypes
         array.each do |e|
           child_links = []
           context = SerializationDSL.new(__getobj__, child_links, context: @serialization_context)
-          serializer.serialize(e, identifier, @serialization_context, dsl: context)
+          serializer.serialize(e, identifier, context: @serialization_context, dsl: context)
 
           self_links = child_links.select { |l| l[:rel] == :self }
           raise NoSelfLinkProvidedError, identifier unless self_links.any?
@@ -79,7 +79,7 @@ module MediaTypes
 
         array.each do |e|
           context = SerializationDSL.new(__getobj__, [], @serialization_vary, context: @serialization_context)
-          result = serializer.serialize(e, identifier, @serialization_context, dsl: context, raw: true)
+          result = serializer.serialize(e, identifier, context: @serialization_context, dsl: context, raw: true)
 
           result = block.call(result) unless block.nil?
 
@@ -105,7 +105,7 @@ module MediaTypes
       def emit
         serialization_dsl_result
       end
-      
+
       def object(&block)
         context = SerializationDSL.new(__getobj__, @serialization_links, @serialization_vary, context: @serialization_context)
         context.instance_exec(&block)

data/lib/media_types/serialization/serialization_registration.rb

@@ -31,14 +31,23 @@ module MediaTypes
         register_wildcards(identifier, registration) if wildcards && inout == :output
       end
 
-      def register_alias(serializer, alias_identifier, target_identifier, optional, wildcards: true)
-        raise DuplicateDefinitionError.new(identifier, inout) if registrations.key? alias_identifier
+      def register_alias(serializer, alias_identifier, target_identifier, optional, hide_variant, wildcards: true)
+        raise DuplicateDefinitionError.new(alias_identifier, inout) if registrations.key? alias_identifier
 
-        raise UnbackedAliasDefinitionError.new(target_identifier, inout) unless registrations.key? target_identifier
+        unless registrations.key? target_identifier
+          potential_match = registrations.keys.find do |k|
+            k.starts_with? target_identifier
+          end
+          raise VersionedAliasDefinitionError.new(target_identifier, inout, potential_match) unless potential_match.nil?
+          raise UnbackedAliasDefinitionError.new(target_identifier, inout)
+        end
 
         target = registrations[target_identifier]
 
-        registration = SerializationAliasRegistration.new serializer, inout, target.validator, alias_identifier, target, optional
+        result_content_type = alias_identifier
+        result_content_type += "; variant=#{target_identifier}" unless hide_variant
+
+        registration = SerializationAliasRegistration.new serializer, inout, target.validator, result_content_type, target, optional, hide_variant
         registrations[alias_identifier] = registration
 
         register_wildcards(alias_identifier, registration) if wildcards && inout == :output
@@ -103,7 +112,7 @@ module MediaTypes
       private
 
       def register_wildcards(identifier, registration)
-        new_alias = SerializationAliasRegistration.new registration.serializer, registration.inout, registration.validator, identifier, registration, true
+        new_alias = SerializationAliasRegistration.new registration.serializer, registration.inout, registration.validator, identifier, registration, true, true
 
         registrations['*/*'] = new_alias unless has? '*/*'
 
@@ -160,14 +169,14 @@ module MediaTypes
             begin
               victim = MediaTypes::Serialization.json_decoder.call(victim)
               validator.validate!(victim)
-            rescue MediaTypes::Scheme::ValidationError, Oj::ParseError, JSON::ParserError => inner
+            rescue MediaTypes::Scheme::ValidationError, Oj::ParseError, JSON::ParserError, EncodingError => inner
               raise InputValidationFailedError, inner
             end
           else
             begin
               victim = MediaTypes::Serialization.json_decoder.call(victim)
               validator.validate!(victim)
-            rescue MediaTypes::Scheme::ValidationError, JSON::ParserError => inner
+            rescue MediaTypes::Scheme::ValidationError, JSON::ParserError, EncodingError => inner
               raise InputValidationFailedError, inner
             end
           end
@@ -204,9 +213,10 @@ module MediaTypes
 
     # A registration that calls another registration when called.
     class SerializationAliasRegistration < SerializationBaseRegistration
-      def initialize(serializer, inout, validator, display_identifier, target, optional)
+      def initialize(serializer, inout, validator, display_identifier, target, optional, hide_variant)
         self.target = target
         self.optional = optional
+        self.hide_variant = hide_variant
         super(serializer, inout, validator, display_identifier)
       end
 
@@ -229,7 +239,7 @@ module MediaTypes
         target.call(victim, context, dsl: dsl, raw: raw)
       end
 
-      attr_accessor :target, :optional
+      attr_accessor :target, :optional, :hide_variant
     end
   end
 end

data/lib/media_types/serialization/serializers/problem_serializer.rb

@@ -2,6 +2,7 @@
 
 require 'erb'
 require 'media_types/serialization/base'
+require 'media_types/serialization/utils/accept_language_header'
 
 module MediaTypes
   module Serialization
@@ -9,13 +10,19 @@ module MediaTypes
       class ProblemSerializer < MediaTypes::Serialization::Base
 
         unvalidated 'application/vnd.delftsolutions.problem'
+        disable_wildcards
 
         output do |problem, _, context|
           raise 'No translations defined, add at least one title' unless problem.translations.keys.any?
 
-          # TODO: content-language selection
-          
-          translation = problem.translations[problem.translations.keys.first]
+          accept_language_header = Utils::AcceptLanguageHeader.new(context.request.get_header(HEADER_ACCEPT_LANGUAGE) || '')
+          translation_entry = accept_language_header.map do |locale|
+            problem.translations.keys.find do |l|
+              l.start_with? locale.locale
+            end
+          end.compact.first || problem.translations.keys.first
+          translation = problem.translations[translation_entry]
+
           title = translation[:title]
           detail = translation[:detail] || problem.error.message
 
@@ -33,12 +40,19 @@ module MediaTypes
         output_alias 'application/problem+json'
 
         output_raw view: :html do |problem, _, context|
-          # TODO: content-language selection
-          
-          translation = problem.translations[problem.translations.keys.first]
+          accept_language_header = Utils::AcceptLanguageHeader.new(context.request.get_header(HEADER_ACCEPT_LANGUAGE) || '')
+          translation_entry = accept_language_header.map do |locale|
+            problem.translations.keys.find do |l|
+              l.starts_with? locale.locale
+            end
+          end.compact.first || problem.translations.keys.first
+          translation = problem.translations[translation_entry]
+
           title = translation[:title]
           detail = translation[:detail] || problem.error.message
 
+          detail_lang = translation[:detail].nil? ? 'en' : translation_entry
+
           input = OpenStruct.new(
             title: title,
             detail: detail,
@@ -61,11 +75,11 @@ module MediaTypes
                 </header>
                 <section id="content">
                   <nav>
-                    <section id="description">
+                    <section id="description" lang="#{translation_entry}">
                       <h2><a href="<%= help_url %>"><%= CGI::escapeHTML(title) %></a></h2>
                     </section>
                   </nav>
-                  <main>
+                  <main lang="#{detail_lang}">
                     <p><%= detail %>
                   </main>
                 </section>
@@ -76,8 +90,7 @@ module MediaTypes
           template.result(input.instance_eval { binding })
         end
 
-        # Hack: results in the alias being registered as */* wildcard
-        self.serializer_output_registration.registrations.delete('*/*')
+        enable_wildcards
 
         output_alias_optional 'text/html', view: :html