media_types-serialization 1.0.1 → 1.2.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)
@@ -67,7 +67,21 @@ module MediaTypes
           quirks_mode: false
         )
       }
-      self.json_decoder = Oj.method(:load)
+      self.json_decoder = ->(obj) {
+        Oj.load(obj,
+          mode:       :compat,
+          ascii_only: false,
+          allow_nan:  false,
+          symbol_keys: true,
+          allow_nil: false,
+          allow_invalid_unicode: false,
+          array_class: ::Array,
+          create_additions: false,
+          hash_class: ::Hash,
+          nilnil: false,
+          quirks_mode: false
+        )
+      }
     else
       require 'json'
       self.json_encoder = JSON.method(:pretty_generate)
@@ -169,7 +183,66 @@ module MediaTypes
           @serialization_output_registrations = @serialization_output_registrations.merge(mergeable_outputs)
         end
       end
-      
+
+      def allow_output_html(as: nil, view: nil, layout: 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|
+            if layout.nil?
+              if view.nil?
+                controller.render_to_string
+              else
+                controller.render_to_string(template: view)
+              end
+            else
+              if view.nil?
+                controller.render_to_string(layout: layout)
+              else
+                controller.render_to_string(template: view, layout: layout)
+              end
+            end
+          }
+
+          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 ||= {}
@@ -202,7 +275,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] ||= {}
@@ -245,8 +318,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'
@@ -352,7 +425,7 @@ 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
@@ -372,7 +445,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
@@ -389,7 +462,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

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)

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_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
 

data/lib/media_types/serialization/utils/accept_header.rb

@@ -0,0 +1,77 @@
+=begin
+The MIT License (MIT)
+
+Copyright (c) 2019 Derk-Jan Karrenbeld
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+=end
+
+require 'media_types/serialization/utils/header_list'
+
+module MediaTypes
+  module Serialization
+    module Utils
+      class AcceptHeader < DelegateClass(Array)
+        def initialize(value)
+          __setobj__ HeaderList.new(value, entry_klazz: AcceptHeader::Entry)
+        end
+
+        class Entry
+          def initialize(media_type, index:, parameters:)
+            self.media_type = media_type
+            self.parameters = parameters
+            self.index = index
+
+            freeze
+          end
+
+          attr_reader :media_type
+
+          # noinspection RubyInstanceMethodNamingConvention
+          def q
+            parameters.fetch(:q) { 1.0 }.to_f
+          end
+
+          def <=>(other)
+            quality = other.q <=> q
+            return quality unless quality.zero?
+            index <=> other.send(:index)
+          end
+
+          def [](parameter)
+            parameters.fetch(String(parameter).to_sym)
+          end
+
+          def to_header
+            to_s
+          end
+
+          def to_s
+            [media_type].concat(parameters.map { |k, v| "#{k}=#{v}" }).compact.reject(&:empty?).join('; ')
+          end
+
+          private
+
+          attr_writer :media_type
+          attr_accessor :parameters, :index
+        end
+      end
+    end
+  end
+end