media_types-serialization 0.1.0

data/Rakefile

@@ -0,0 +1,10 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList["test/**/*_test.rb"]
+end
+
+task :default => :test

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "media_types/serialization"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/media_types/serialization.rb

@@ -0,0 +1,194 @@
+require 'media_types/serialization/version'
+
+require 'abstract_controller'
+require 'action_controller/metal/mime_responds'
+require 'action_dispatch/http/mime_type'
+require 'active_support/concern'
+require 'active_support/core_ext/module/attribute_accessors'
+
+require 'http_headers/accept'
+
+require 'media_types/serialization/no_media_type_serializers'
+require 'media_types/serialization/no_serializer_for_content_type'
+require 'media_types/serialization/wrapper/html_wrapper'
+require 'media_types/serialization/wrapper/media_wrapper'
+
+module MediaTypes
+  module Serialization
+
+    mattr_accessor :common_suffix
+
+    extend ActiveSupport::Concern
+
+    HEADER_ACCEPT = 'HTTP_ACCEPT'
+    MEDIA_TYPE_HTML = 'text/html'
+
+    # rubocop:disable Metrics/BlockLength
+    class_methods do
+      # @see #freeze_accepted_media!
+      #
+      def accept_serialization(serializer, view: [nil], accept_html: true, **filter_opts)
+        before_action(**filter_opts) do
+          self.serializers = resolved_media_types(serializer, view: view) do |media_type, media_view, res|
+            opts = { media_type: media_type, media_view: media_view }
+
+            res[MEDIA_TYPE_HTML] = wrap_html(serializer, **opts) if accept_html && !res[MEDIA_TYPE_HTML]
+            res[String(media_type)] = wrap_media(serializer, **opts) if media_type != MEDIA_TYPE_HTML
+          end
+        end
+      end
+
+      def accept_html(serializer, **filter_opts)
+        before_action(**filter_opts) do
+          self.serializers = resolved_media_types(serializer, view: nil) do |_, media_view, res|
+            res[MEDIA_TYPE_HTML] = wrap_html(serializer, media_view: media_view, media_type: MEDIA_TYPE_HTML)
+            break
+          end
+        end
+      end
+
+      ##
+      # Register a mime type, but explicitly notify that it can't be serialized.
+      # This is done for file serving and redirects.
+      #
+      # @param [Symbol] mimes takes a list of symbols that should resolve through Mime::Type
+      #
+      # @see #freeze_accepted_media!
+      #
+      # @example fingerpint binary format
+      #
+      #   no_serializer_for :fingerprint_bin, :fingerprint_deprecated_bin
+      #
+      def accept_without_serialization(*mimes, **filter_opts)
+        before_action(**filter_opts) do
+          self.serializers = Array(mimes).each_with_object(Hash(serializers)) do |mime, res|
+            res[(Mime::Type.lookup_by_extension(mime) || mime).to_s] = nil
+          end
+        end
+      end
+
+      ##
+      # Freezes additions to the serializes and notifies the controller what it will be able to respond to.
+      #
+      def freeze_accepted_media!
+        before_action do
+          # If the responders gem is available, this freezes what a controller can respond to
+          if self.class.respond_to?(:respond_to)
+            self.class.respond_to(*Hash(serializers).keys.map { |type| Mime::Type.lookup(type) })
+          end
+          serializers.freeze
+        end
+      end
+    end
+    # rubocop:enable Metrics/BlockLength
+
+    included do
+      protected
+
+      attr_accessor :serializers
+    end
+
+    protected
+
+    def media_type_serializer
+      @media_type_serializer ||= resolve_media_type_serializer
+    end
+
+    def serialize_media(media, serializer: media_type_serializer)
+      @last_serialize_media = media
+      @last_media_serializer = serializer.call(media, context: self)
+    end
+
+    def media_type_json_root
+      String(request.format.symbol).sub(/_json$/, '')
+    end
+
+    def respond_to_matching(matcher, &block)
+      respond_to do |format|
+        serializers.each_key do |mime|
+          next unless matcher.call(mime: mime, format: format)
+          format.custom(mime, &block)
+        end
+      end
+    end
+
+    def respond_to_accept(&block)
+      respond_to do |format|
+        serializers.each_key do |mime|
+          format.custom(mime, &block)
+        end
+
+        format.any { raise_no_accept_serializer }
+      end
+    end
+
+    def request_accept
+      @request_accept ||= HttpHeaders::Accept.new(request.get_header(HEADER_ACCEPT) || '')
+    end
+
+    def raise_no_accept_serializer
+      raise NoSerializerForContentType.new(request_accept, serializers.keys)
+    end
+
+    private
+
+    def extract_synonym_version(synonym)
+      synonym.rpartition('.').last[1..-1]
+    end
+
+    def resolve_media_type_serializer
+      raise NoMediaTypeSerializers unless serializers
+
+      # Rails negotiation
+      if serializers[request.format.to_s]
+        return serializers[request.format.to_s]
+      end
+
+      # Ruby negotiation
+      request.accepts.each do |mime_type|
+        next unless serializers.key?(mime_type.to_s)
+        # Override Rails selected format
+        request.set_header("action_dispatch.request.formats", [mime_type])
+        return serializers[mime_type.to_s]
+      end
+
+      raise_no_accept_serializer
+    end
+
+    def resolved_media_types(serializer, view:)
+      Array(view).each_with_object(Hash(serializers)) do |media_view, res|
+        media_view = String(media_view)
+        Array(serializer.media_type(view: media_view)).each do |media_type|
+          yield media_type, media_view, res
+        end
+      end
+    end
+
+    def wrap_media(serializer, media_view:, media_type:)
+      lambda do |*args, **opts|
+        Wrapper::MediaWrapper.new(
+          serializer.new(*args, media_type: media_type, view: media_view, **opts),
+          view: media_view
+        )
+      end
+    end
+
+    def wrap_html(serializer, media_view:, media_type:)
+      lambda do |*args, **opts|
+        media_serializer = wrap_media(
+          serializer,
+          media_view: media_view,
+          media_type: media_type
+        ).call(*args, **opts)
+
+        Wrapper::HtmlWrapper.new(
+          media_serializer,
+          view: media_view,
+          mime_type: media_type.to_s,
+          representations: serializers.keys,
+          url_context: request.original_fullpath.chomp(".#{request.format.symbol}")
+        )
+      end
+    end
+  end
+end

data/lib/media_types/serialization/base.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+require 'uri'
+
+require 'media_types/serialization/mime_type_support'
+require 'media_types/serialization/migrations_support'
+
+module MediaTypes
+  module Serialization
+    class Base
+      include MimeTypeSupport
+      include MigrationsSupport
+
+      attr_accessor :serializable
+
+      def initialize(serializable, media_type:, view: nil, context:)
+        self.context = context
+        self.current_media_type = media_type
+        self.current_view = view
+
+        set(serializable)
+      end
+
+      def to_link_header
+        {}
+      end
+
+      def to_html
+        raise NotImplementedError, format(
+          'In %<class>s, to_html is not implemented.',
+          class: self.class.name
+        )
+      end
+
+      def to_xml
+        raise NotImplementedError, format(
+          'In %<class>s, to_xml is not implemented.',
+          class: self.class.name
+        )
+      end
+
+      def to_hash
+        raise NotImplementedError, format(
+          'In %<class>s, to_hash is not implemented.',
+          class: self.class.name
+        )
+      end
+
+      def to_text
+        raise NotImplementedError, format(
+          'In %<class>s, to_text is not implemented/',
+          class: self.class.name
+        )
+      end
+
+      def to_json
+        raise NotImplementedError, format(
+          'In %<class>s, to_json is not implemented/',
+          class: self.class.name
+        )
+      end
+
+      def to_h
+        raise NotImplementedError, format(
+          'In %<class>s, to_h is not implemented. Missing alias to_h to_hash.',
+          class: self.class.name
+        )
+      end
+
+      def to_body
+        raise NotImplementedError, format(
+          'In %<class>s, to_body is not implemented. This is a general purpose catch all renderer',
+          class: self.class.name
+        )
+      end
+
+      def respond_to?(sym, include_all = false)
+        return false if [:to_h, :to_hash, :to_json, :to_text, :to_xml, :to_html, :to_body, :extract_self].include?(sym)
+        return true if sym == :to_link_header
+
+        super
+      end
+
+      protected
+
+      attr_accessor :context, :current_media_type, :current_view
+
+      def extract_self
+        raise NotImplementedError, format(
+          'In %<class>s, extract_self is not implemented, thus a self link for %<model>s can not be generated. ' \
+          'Implement extract_self on %<class>s or deny the MediaType[s] %<media_types>s for this request.',
+          class: self.class.name,
+          model: serializable.class.name,
+          media_types: self.class.media_types(view: '[view]').to_s
+        )
+      end
+
+      def extract_links
+        {}
+      end
+
+      def header_links
+        extract_links
+      end
+
+      def set(serializable)
+        self.serializable = serializable
+        self
+      end
+
+      def extract(extractable, *keys)
+        return {} unless keys.present?
+        extractable.slice(*keys)
+      rescue TypeError => err
+        raise TypeError, format(
+          '[serializer] failed to slice keys to extract. Given keys: %<keys>s. Extractable: %<extractable>s' \
+          'Error: %<error>s',
+          keys: keys,
+          extractable: extractable,
+          error: err
+        )
+      end
+
+      def resolve_file_url(url)
+        return url if !url || URI(url).absolute?
+
+        format(
+          'https://%<host>s:%<port>s%<path>s',
+          host: context.default_url_options[:host],
+          port: context.default_url_options[:port],
+          path: url
+        )
+      rescue URI::InvalidURIError
+        url
+      end
+    end
+  end
+end

data/lib/media_types/serialization/error.rb

@@ -0,0 +1,7 @@
+
+module MediaTypes
+  module Serialization
+    class Error < StandardError
+    end
+  end
+end

data/lib/media_types/serialization/migrations_command.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+#
+module MediaTypes
+  module Serialization
+    class MigrationsCommand
+      def initialize(serializer)
+        self.serializer = serializer
+        self.migrations = {}
+      end
+
+      def call(result, mime_type, view)
+        return result if matches_current_mime_type?(view: view, mime_type: mime_type)
+
+        migrations.reduce(result) do |migrated, (version, migration)|
+          migrated = migration.call(migrated)
+          next migrated unless matches_mime_type?(mime_type.version(version), mime_type)
+          break migrated
+        end
+      end
+
+      private
+
+      attr_accessor :serializer, :migrations
+
+      def version(version, &block)
+        migrations[version] = ->(result) { serializer.instance_exec(result, &block) }
+      end
+
+      def matches_current_mime_type?(view:, mime_type:)
+        serializer.class.current_mime_type(view: view) == mime_type.to_s
+      end
+
+      def matches_mime_type?(left, right)
+        left.to_s == right.to_s
+      end
+    end
+  end
+end

data/lib/media_types/serialization/migrations_support.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require 'active_support/concern'
+require 'media_types/serialization/migrations_command'
+
+module MediaTypes
+  module Serialization
+    module MigrationsSupport
+      extend ActiveSupport::Concern
+
+      included do
+        mattr_accessor :migrations
+      end
+
+      class_methods do
+        def migrator(serializer)
+          return nil unless migrations
+          migrations.call(serializer)
+        end
+
+        protected
+
+        def backward_migrations(&block)
+          self.migrations = lambda do |serializer|
+            MigrationsCommand.new(serializer).tap do |callable|
+              callable.instance_exec(&block)
+            end
+          end
+        end
+      end
+
+      def migrate(result = nil, media_type = current_media_type, view = current_view)
+        result ||= yield
+
+        migrator = self.class.migrator(self)
+        return result unless migrator
+        migrator.call(result, media_type, view)
+      end
+    end
+  end
+end