media_types-serialization 0.8.1 → 1.0.1

data/lib/generators/media_types/serialization/api_viewer/templates/initializer.rb

@@ -1,33 +0,0 @@
-require 'media_types/serialization'
-
-# This registers the renderer as side-effect
-require 'media_types/serialization/renderer/register'
-
-# This registers the media type as side-effect
-require 'media_types/serialization/media_type/register'
-
-##
-# The following options are breaking and therefore disabled by default.
-#
-# When these are true, the +header_links+ and +extract_links+ methods is called
-# when dealing with a .collection or .index view, respectively. It allows you
-# to define +_links+ for the root level from your serializer.
-#
-#
-MediaTypes::Serialization.collect_links_for_collection = true
-MediaTypes::Serialization.collect_links_for_index = true
-
-##
-# The API Viewer template is provided if you used the generator. You can change
-# the view it renders by changing the path below.
-#
-#
-# ::MediaTypes::Serialization.api_viewer_layout = '/path/to/wrapper/layout'
-
-##
-# When .to_html is not provided by a serializer, it will fall back to render
-# the API Viewer, but this template can be changed by changing the path
-# below.
-#
-#
-# ::MediaTypes::Serialization.html_wrapper_layout = '/path/to/wrapper/layout'

data/lib/generators/media_types/serialization/api_viewer/templates/template_controller.rb

@@ -1,23 +0,0 @@
-module Api
-  class TemplateController < ApiController
-    def create
-      href = params[:template].delete(:href)
-      templated_values = params[:template].permit!.to_h
-
-      response["Location"] = templated_values.reduce(href) do |result, (key, value)|
-        result.sub!(%r{:#{key}|{#{key}}|%7B#{key}%7D}, value) || invalid_parameter(key, href)
-      end
-      head :temporary_redirect
-    end
-
-    private
-
-    def invalid_parameter(key, href)
-      raise ActionController::BadRequest, format(
-        'Received templated value for "%<key>s" which does not exist in templated link "%<href>s"',
-        key: key,
-        href: href.gsub('%7B', '{').gsub('%7D', '}')
-      )
-    end
-  end
-end

data/lib/media_types/serialization/media_type/register.rb

@@ -1,4 +0,0 @@
-require 'action_dispatch/http/mime_type'
-require 'media_types/serialization'
-
-Mime::Type.register(MediaTypes::Serialization::MEDIA_TYPE_API_VIEWER, :api_viewer)

data/lib/media_types/serialization/migrations_command.rb

@@ -1,38 +0,0 @@
-# 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 mime_type.is_a?(String) || 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

@@ -1,50 +0,0 @@
-# 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
-        # This is the same as doing matrr_accessor but have it isolated to the class. Subclass changes to change these
-        # values, but this allows for definition as a concern.
-
-        class << self
-          attr_accessor :migrations
-        end
-
-        delegate :migrations,
-                 :migrations=,
-                 to: :class
-      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

data/lib/media_types/serialization/mime_type_support.rb

@@ -1,64 +0,0 @@
-# frozen_string_literal: true
-
-require 'active_support/concern'
-
-module MediaTypes
-  module Serialization
-    module MimeTypeSupport
-      extend ActiveSupport::Concern
-
-      included do
-        # This is the same as doing matrr_accessor but have it isolated to the class. Subclass changes to change these
-        # values, but this allows for definition as a concern.
-
-        class << self
-          attr_accessor :media_type_constructable, :serializes_html_flag, :media_type_versions
-        end
-
-        delegate :media_type_constructable, :serializes_html_flag, :media_type_versions,
-                 :media_type_constructable=, :serializes_html_flag=, :media_type_versions=,
-                 to: :class
-      end
-
-      class_methods do
-        def current_mime_type(view: nil)
-          media_type_constructable&.view(view)
-        end
-
-        def media_types(view: nil)
-          media_type_view = current_mime_type(view: view)
-
-          suffixes = [].tap do |result|
-            result << :json if instance_methods.include?(:to_json)
-            result << :xml if instance_methods.include?(:to_xml)
-          end
-
-          additionals = [].tap do |result|
-            result << 'text/html' if serializes_html_flag || instance_methods.include?(:to_html)
-          end
-
-          [media_type_view].concat(
-            media_type_versions.map { |version| media_type_view&.version(version) },
-            media_type_versions.flat_map do |version|
-              (suffixes).map { |suffix| media_type_view&.suffix(suffix)&.version(version) }
-            end,
-            additionals
-          ).compact.uniq
-        end
-
-        alias_method :media_type, :media_types
-
-        protected
-
-        def serializes_media_type(media_type, additional_versions: [])
-          self.media_type_constructable = media_type&.to_constructable
-          self.media_type_versions = additional_versions
-        end
-
-        def serializes_html
-          self.serializes_html_flag = true
-        end
-      end
-    end
-  end
-end

data/lib/media_types/serialization/no_content_type_given.rb

@@ -1,11 +0,0 @@
-require 'media_types/serialization/error'
-
-module MediaTypes
-  module Serialization
-    class NoContentTypeGiven < Error
-      def initialize
-        super 'Unable to render data because :content_type was not passed in to "render media: data, content_type: ..."'
-      end
-    end
-  end
-end

data/lib/media_types/serialization/no_media_type_serializers.rb

@@ -1,11 +0,0 @@
-require 'media_types/serialization/error'
-
-module MediaTypes
-  module Serialization
-    class NoMediaTypeSerializers < Error
-      def initialize
-        super 'No serializer has been set up for this request. You can not fix this by changing the request headers.'
-      end
-    end
-  end
-end

data/lib/media_types/serialization/no_serializer_for_content_type.rb

@@ -1,15 +0,0 @@
-require 'media_types/serialization/error'
-
-module MediaTypes
-  module Serialization
-    class NoSerializerForContentType < Error
-      def initialize(given, supported)
-        super format(
-          'Unable to serialize to requested Content-Type: %<given>s. I can give you: %<supported>s',
-          given: Array(given).map(&:to_s).inspect,
-          supported: supported.map(&:to_s)
-        )
-      end
-    end
-  end
-end

data/lib/media_types/serialization/renderer.rb

@@ -1,41 +0,0 @@
-require 'media_types/serialization/no_content_type_given'
-require 'active_support/core_ext/object/blank'
-require 'active_support/core_ext/hash/conversions'
-
-require 'media_types/serialization'
-
-module MediaTypes
-  module Serialization
-    # noinspection RubyConstantNamingConvention
-    Renderer = lambda do |obj, options|
-      content_type = options[:content_type] ||
-        options[:mime_type]&.to_s ||
-        self.content_type&.to_s ||
-        obj.current_media_type.to_s
-
-      raise NoContentTypeGiven if content_type.blank?
-
-      self.content_type ||= content_type
-
-      if content_type.ends_with?('+json') || Mime::Type.lookup(content_type) == Mime[:json]
-        obj.respond_to?(:to_json) ? obj.to_json(options) : obj.to_hash.to_json(options)
-      elsif content_type.ends_with?('+xml') || Mime::Type.lookup(content_type) == Mime[:xml]
-        obj.respond_to?(:to_xml) ? obj.to_xml(options) : obj.to_hash.to_xml(options)
-      elsif Mime::Type.lookup(content_type) == Mime[:html] && obj.respond_to?(:to_html)
-        obj.to_html
-      elsif content_type === MEDIA_TYPE_API_VIEWER && obj.respond_to?(:to_api_viewer)
-        obj.to_api_viewer(content_type: options[:api_viewer_content_type]).tap do
-          self.content_type = 'text/html' # because the api viewer will not be seen as
-        end
-      else
-        obj.to_body(content_type: options.delete(:content_type) || content_type, **options)
-      end
-    end
-
-    module_function
-
-    def register_renderer
-      ::ActionController::Renderers.add :media, &Renderer
-    end
-  end
-end

data/lib/media_types/serialization/renderer/register.rb

@@ -1,4 +0,0 @@
-require 'action_controller/metal/renderers'
-require 'media_types/serialization/renderer'
-
-::MediaTypes::Serialization.register_renderer

data/lib/media_types/serialization/wrapper.rb

@@ -1,13 +0,0 @@
-# frozen_string_literal: true
-
-require 'media_types/serialization/wrapper/html_wrapper'
-require 'media_types/serialization/wrapper/media_object_wrapper'
-require 'media_types/serialization/wrapper/media_index_wrapper'
-require 'media_types/serialization/wrapper/media_collection_wrapper'
-
-module MediaTypes
-  module Serialization
-    module Wrapper
-    end
-  end
-end

data/lib/media_types/serialization/wrapper/html_wrapper.rb

@@ -1,45 +0,0 @@
-# frozen_string_literal: true
-
-require 'delegate'
-
-require 'action_controller'
-
-module MediaTypes
-  module Serialization
-    module Wrapper
-      class HtmlWrapper < SimpleDelegator
-
-        delegate :to_s, to: :to_html
-        delegate :class, to: :__getobj__
-
-        def initialize(serializer, view: nil, **render_options)
-          __setobj__ serializer
-
-          self.view = view
-          self.render_options = render_options
-        end
-
-        def to_html
-          return super if __getobj__.respond_to?(:to_html)
-          to_api_viewer(layout: ::MediaTypes::Serialization.html_wrapper_layout)
-        end
-
-        def to_api_viewer(content_type: nil, layout: ::MediaTypes::Serialization.api_viewer_layout)
-          ActionController::Base.render(
-            layout || 'serializers/wrapper/html_wrapper',
-            assigns: {
-              serializer: self,
-              view: view,
-              content_type: content_type,
-              **render_options
-            }
-          )
-        end
-
-        private
-
-        attr_accessor :view, :render_options
-      end
-    end
-  end
-end

data/lib/media_types/serialization/wrapper/media_collection_wrapper.rb

@@ -1,61 +0,0 @@
-# frozen_string_literal: true
-
-require 'delegate'
-
-require 'active_support/core_ext/string/inflections'
-
-module MediaTypes
-  module Serialization
-    module Wrapper
-      class MediaCollectionWrapper < SimpleDelegator
-
-        delegate :to_json, to: :to_hash
-        delegate :class, :set, :current_view, :current_media_type, to: :__getobj__
-        attr_accessor :inner_serializer
-
-        def initialize(serializer)
-          self.inner_serializer = serializer.dup
-          __setobj__ serializer
-        end
-
-        def to_hash
-          {
-            root_key => {
-              '_embedded': wrapped_serializable.map(&method(:item_hash)),
-              '_links': extract_links
-            }
-          }
-        end
-        alias to_h to_hash
-
-        def header_links(view: current_view)
-          return __getobj__.send(:header_links, view: view) if ::MediaTypes::Serialization.collect_links_for_collection
-          {}
-        end
-
-        protected
-
-        def extract_links(view: current_view)
-          return __getobj__.send(:extract_set_links, view: view) if ::MediaTypes::Serialization.collect_links_for_collection
-          {}
-        end
-
-        def wrapped_serializable
-          return __getobj__.wrapped_serializable if __getobj__.respond_to?(:wrapped_serializable)
-          return [serializable] if serializable.is_a?(::Hash)
-          Array(serializable)
-        end
-
-        def item_hash(item)
-          inner_serializer.instance_exec do
-            set(item).to_hash
-          end
-        end
-
-        def root_key(view: current_view)
-          __getobj__.class.root_key(view: view)
-        end
-      end
-    end
-  end
-end

data/lib/media_types/serialization/wrapper/media_index_wrapper.rb

@@ -1,61 +0,0 @@
-# frozen_string_literal: true
-
-require 'delegate'
-
-require 'active_support/core_ext/string/inflections'
-
-module MediaTypes
-  module Serialization
-    module Wrapper
-      class MediaIndexWrapper < SimpleDelegator
-
-        delegate :to_json, to: :to_hash
-        delegate :class, :set, :current_view, :current_media_type, to: :__getobj__
-        attr_accessor :inner_serializer
-
-        def initialize(serializer)
-          self.inner_serializer = serializer.dup
-          __setobj__ serializer
-        end
-
-        def to_hash
-          {
-            root_key => {
-              '_index': wrapped_serializable.map(&method(:item_hash)),
-              '_links': extract_links
-            }
-          }
-        end
-        alias to_h to_hash
-
-        def header_links(view: current_view)
-          return __getobj__.send(:header_links, view: view) if ::MediaTypes::Serialization.collect_links_for_index
-          {}
-        end
-
-        protected
-
-        def wrapped_serializable
-          return __getobj__.wrapped_serializable if __getobj__.respond_to?(:wrapped_serializable)
-          return [serializable] if serializable.is_a?(::Hash)
-          Array(serializable)
-        end
-
-        def item_hash(item)
-          inner_serializer.instance_exec do
-            set(item).send(:extract_self)
-          end
-        end
-
-        def extract_links(view: current_view)
-          return __getobj__.send(:extract_set_links, view: view) if ::MediaTypes::Serialization.collect_links_for_index
-          {}
-        end
-
-        def root_key(view: current_view)
-          __getobj__.class.root_key(view: view)
-        end
-      end
-    end
-  end
-end