media_types-serialization 0.1.0

data/lib/media_types/serialization/mime_type_support.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require 'active_support/concern'
+
+module MediaTypes
+  module Serialization
+    module MimeTypeSupport
+      extend ActiveSupport::Concern
+
+      included do
+        mattr_accessor :media_type_constructable, :serializes_html_flag, :media_type_versions
+      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 self.instance_methods(false).include?(:to_json)
+            result << :xml if self.instance_methods(false).include?(:to_xml)
+          end
+
+          additionals = [].tap do |result|
+            result << 'text/html' if serializes_html_flag || self.instance_methods(false).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

@@ -0,0 +1,11 @@
+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

@@ -0,0 +1,11 @@
+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

@@ -0,0 +1,15 @@
+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: given.inspect,
+          supported: supported.map(&:to_s)
+        )
+      end
+    end
+  end
+end

data/lib/media_types/serialization/renderer.rb

@@ -0,0 +1,31 @@
+require 'media_types/serialization/no_content_type_given'
+require 'active_support/core_ext/object/blank'
+require 'active_support/core_ext/hash/conversions'
+
+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.class.instance_methods(false).include?(: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.class.instance_methods(false).include?(:to_xml) ? obj.to_xml(options) : obj.to_hash.to_xml(options)
+      elsif Mime::Type.lookup(content_type) == Mime[:html]
+        obj.class.instance_methods(false).include?(:to_html) ? obj.to_html : obj.to_s
+      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

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

data/lib/media_types/serialization/version.rb

@@ -0,0 +1,5 @@
+module MediaTypes
+  module Serialization
+    VERSION = "0.1.0"
+  end
+end

data/lib/media_types/serialization/wrapper.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require 'media_types/serialization/wrapper/root_key'
+require 'media_types/serialization/wrapper/html_wrapper'
+require 'media_types/serialization/wrapper/media_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

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require 'delegate'
+
+require 'action_controller'
+
+require 'media_types/serialization/base'
+require 'media_types/serialization/wrapper/root_key'
+
+module MediaTypes
+  module Serialization
+    module Wrapper
+      class HtmlWrapper < DelegateClass(Base)
+
+        delegate :to_s, to: :to_html
+        delegate :class, to: :__getobj__
+
+        def initialize(serializer, view: nil, **render_options)
+          super serializer
+          self.view = view
+          self.render_options = render_options
+        end
+
+        def to_html
+          return super if __getobj__.respond_to?(:to_html)
+          ActionController::Base.render(
+            'serializers/wrapper/html_wrapper',
+            assigns: {
+              serializer: self,
+              view: view,
+              **render_options
+            }
+          )
+        end
+
+        private
+
+        attr_accessor :view, :render_options
+      end
+    end
+  end
+end

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

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require 'delegate'
+
+require 'active_support/core_ext/string/inflections'
+
+require 'media_types/serialization/base'
+require 'media_types/serialization/wrapper/root_key'
+
+module MediaTypes
+  module Serialization
+    module Wrapper
+      class MediaCollectionWrapper < DelegateClass(Base)
+
+        delegate :to_json, to: :to_hash
+        delegate :class, to: :__getobj__
+
+        def initialize(serializer)
+          super serializer
+        end
+
+        def to_hash
+          { Wrapper::RootKey.new(__getobj__.class).pluralize => {
+            '_embedded': auto_wrap_serializable.map(&method(:item_hash)),
+            '_links': {}
+          } }
+        end
+        alias to_h to_hash
+
+        def collect_links
+          {}
+        end
+
+        private
+
+        def auto_wrap_serializable
+          Array(serializable)
+        end
+
+        def item_hash(item)
+          __getobj__.instance_exec do
+            set(item).send(:to_hash)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require 'delegate'
+
+require 'active_support/core_ext/string/inflections'
+
+require 'media_types/serialization/base'
+require 'media_types/serialization/wrapper/root_key'
+
+module MediaTypes
+  module Serialization
+    module Wrapper
+      class MediaIndexWrapper < DelegateClass(Base)
+
+        delegate :to_json, to: :to_hash
+        delegate :class, to: :__getobj__
+
+        def initialize(serializer)
+          super serializer
+        end
+
+        def to_hash
+          { Wrapper::RootKey.new(__getobj__.class).pluralize => {
+            '_index': auto_wrap_serializable.map(&method(:item_hash)),
+            '_links': {}
+          } }
+        end
+        alias to_h to_hash
+
+        def collect_links
+          {}
+        end
+
+        private
+
+        def auto_wrap_serializable
+          Array(serializable)
+        end
+
+        def item_hash(item)
+          __getobj__.instance_exec do
+            set(item).send(:extract_self)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require 'delegate'
+
+require 'active_support/core_ext/string/inflections'
+
+require 'media_types/serialization/base'
+require 'media_types/serialization/wrapper/media_wrapper'
+require 'media_types/serialization/wrapper/root_key'
+
+module MediaTypes
+  module Serialization
+    module Wrapper
+      class MediaObjectWrapper < DelegateClass(Base)
+
+        delegate :to_json, to: :to_hash
+        delegate :class, to: :__getobj__
+
+        def initialize(serializer)
+          super serializer
+        end
+
+        def to_hash
+          unwrapped = auto_unwrap_serializable.tap { |u| set(u) }
+          { RootKey.new(__getobj__.class).singularize => unwrapped && super || nil }
+        end
+        alias to_h to_hash
+
+        def collect_links
+          return {} unless serializable
+          __getobj__.send(:header_links)
+        end
+
+        private
+
+        AUTO_UNWRAP_KLAZZES = [Array, defined?(ActiveRecord) ? ActiveRecord::Relation : nil].compact.freeze
+
+        def auto_unwrap_serializable
+          return serializable unless AUTO_UNWRAP_KLAZZES.any? { |klazz| serializable.is_a?(klazz) }
+          serializable.first
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require 'media_types'
+
+require 'media_types/serialization/wrapper/media_index_wrapper'
+require 'media_types/serialization/wrapper/media_collection_wrapper'
+require 'media_types/serialization/wrapper/media_object_wrapper'
+
+module MediaTypes
+  module Serialization
+    module Wrapper
+      class MediaWrapper
+
+        AUTO_WRAPPER_MAPPING = {
+          ::MediaTypes::INDEX_VIEW => MediaIndexWrapper,
+          ::MediaTypes::COLLECTION_VIEW => MediaCollectionWrapper,
+          ::MediaTypes::CREATE_VIEW => MediaObjectWrapper,
+          nil => MediaObjectWrapper
+        }.freeze
+
+        DEFAULT_WRAPPER = MediaObjectWrapper
+
+        class << self
+          def new(serializer, view: nil)
+            wrapper = AUTO_WRAPPER_MAPPING.fetch(String(view)) { DEFAULT_WRAPPER }
+            wrapper.new(serializer)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require 'delegate'
+
+require 'active_support/core_ext/object/blank'
+require 'active_support/core_ext/string/inflections'
+
+module MediaTypes
+  module Serialization
+    module Wrapper
+      class RootKey < DelegateClass(String)
+        def initialize(klazz)
+          base = klazz.name.demodulize.chomp(MediaTypes::Serialization.common_suffix || 'Serializer').presence ||
+            klazz.parent.name.demodulize
+          super base.underscore
+        end
+      end
+    end
+  end
+end

data/media_types-serialization.gemspec

@@ -0,0 +1,48 @@
+
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "media_types/serialization/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "media_types-serialization"
+  spec.version       = MediaTypes::Serialization::VERSION
+  spec.authors       = ["Derk-Jan Karrenbeld"]
+  spec.email         = ["derk-jan@xpbytes.com"]
+
+  spec.summary       = 'Add media types supported serialization using your favourite serializer'
+  spec.homepage      = 'https://github.com/XPBytes/media_types-serialization'
+  spec.license       = 'MIT'
+
+  # Prevent pushing this gem to RubyGems.org. To allow pushes either set the 'allowed_push_host'
+  # to allow pushing to a single host or delete this section to allow pushing to any host.
+  if spec.respond_to?(:metadata)
+    # spec.metadata["allowed_push_host"] = "TODO: Set to 'http://mygemserver.com'"
+
+    spec.metadata["homepage_uri"] = spec.homepage
+    spec.metadata["source_code_uri"] = spec.homepage
+    spec.metadata["changelog_uri"] = spec.homepage + '/CHANGELOG.md'
+  else
+    raise "RubyGems 2.0 or newer is required to protect against " \
+      "public gem pushes."
+  end
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency 'actionpack', '>= 4.0.0'
+  spec.add_dependency 'activesupport', '>= 4.0.0'
+  spec.add_dependency 'media_types', '>= 0.6.0'
+  spec.add_dependency 'oj', '>= 3.5.0'
+  spec.add_dependency 'http_headers-accept', '< 1.0.0'
+  spec.add_dependency 'http_headers-link', '< 1.0.0'
+
+  spec.add_development_dependency "bundler", "~> 2.0"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "minitest", "~> 5.0"
+end