jsonapi-materializer 1.0.0.rc2

data/lib/jsonapi/materializer/configuration.rb

@@ -0,0 +1,21 @@
+module JSONAPI
+  module Materializer
+    class Configuration
+      include(ActiveModel::Model)
+
+      attr_accessor(:default_origin)
+      attr_accessor(:default_identifier)
+      attr_accessor(:default_missing_accept_exception)
+      attr_accessor(:default_invalid_accept_exception)
+
+      validates_presence_of(:default_missing_accept_exception)
+      validates_presence_of(:default_invalid_accept_exception)
+
+      def initialize(**keyword_arguments)
+        super(**keyword_arguments)
+
+        validate!
+      end
+    end
+  end
+end

data/lib/jsonapi/materializer/context.rb

@@ -0,0 +1,8 @@
+module JSONAPI
+  module Materializer
+    module Context
+      extend(ActiveSupport::Concern)
+      include(ActiveModel::Model)
+    end
+  end
+end

data/lib/jsonapi/materializer/controller.rb

@@ -0,0 +1,13 @@
+module JSONAPI
+  module Materializer
+    module Controller
+      private def reject_missing_accept_header
+        raise(JSONAPI::Materializer.configuration.default_missing_accept_exception) unless request.headers.key?("Accept")
+      end
+
+      private def reject_invalid_accept_header
+        raise(JSONAPI::Materializer.configuration.default_invalid_accept_exception) unless request.headers.fetch("Accept").include?(JSONAPI::MEDIA_TYPE)
+      end
+    end
+  end
+end

data/lib/jsonapi/materializer/error.rb

@@ -0,0 +1,12 @@
+module JSONAPI
+  module Materializer
+    class Error < StandardError
+      include(ActiveModel::Model)
+
+      require_relative("error/invalid_accept_header")
+      require_relative("error/missing_accept_header")
+      require_relative("error/resource_attribute_not_found")
+      require_relative("error/resource_relationship_not_found")
+    end
+  end
+end

data/lib/jsonapi/materializer/error/invalid_accept_header.rb

@@ -0,0 +1,8 @@
+module JSONAPI
+  module Materializer
+    class Error
+      class InvalidAcceptHeader < Error
+      end
+    end
+  end
+end

data/lib/jsonapi/materializer/error/missing_accept_header.rb

@@ -0,0 +1,8 @@
+module JSONAPI
+  module Materializer
+    class Error
+      class MissingAcceptHeader < Error
+      end
+    end
+  end
+end

data/lib/jsonapi/materializer/error/resource_attribute_not_found.rb

@@ -0,0 +1,14 @@
+module JSONAPI
+  module Materializer
+    class Error
+      class ResourceAttributeNotFound < Error
+        attr_accessor(:name)
+        attr_accessor(:materializer)
+
+        def message
+          "#{materializer} doesn't define the attribute #{name}"
+        end
+      end
+    end
+  end
+end

data/lib/jsonapi/materializer/error/resource_relationship_not_found.rb

@@ -0,0 +1,14 @@
+module JSONAPI
+  module Materializer
+    class Error
+      class ResourceRelationshipNotFound < Error
+        attr_accessor(:name)
+        attr_accessor(:materializer)
+
+        def message
+          "#{materializer} doesn't define the relationship #{name}"
+        end
+      end
+    end
+  end
+end

data/lib/jsonapi/materializer/resource.rb

@@ -0,0 +1,231 @@
+module JSONAPI
+  module Materializer
+    module Resource
+      require_relative("resource/attribute")
+      require_relative("resource/relation")
+      require_relative("resource/relationship")
+      require_relative("resource/configuration")
+
+      extend(ActiveSupport::Concern)
+      include(ActiveModel::Model)
+
+      MIXIN_HOOK = ->(*) do
+        @attributes = {}
+        @relations = {}
+
+        unless const_defined?("Collection")
+          self::Collection = Class.new do
+            include(JSONAPI::Materializer::Collection)
+          end
+        end
+
+        unless const_defined?("Context")
+          self::Context = Class.new do
+            include(JSONAPI::Materializer::Context)
+
+            def initialize(**keyword_arguments)
+              keyword_arguments.keys.each(&singleton_class.method(:attr_accessor))
+
+              super(**keyword_arguments)
+            end
+          end
+        end
+
+        validates_presence_of(:object)
+
+        origin(JSONAPI::Materializer.configuration.default_origin)
+        identifier(JSONAPI::Materializer.configuration.default_identifier)
+
+        has(JSONAPI::Materializer.configuration.default_identifier)
+      end
+
+      attr_accessor(:object)
+      attr_writer(:selects)
+      attr_writer(:includes)
+      attr_writer(:context)
+      attr_reader(:raw)
+
+      def initialize(**keyword_arguments)
+        super(**keyword_arguments)
+
+        @raw = keyword_arguments
+
+        context.validate!
+        validate!
+      end
+
+      def as_data
+        {
+          :id => id,
+          :type => type,
+          :attributes => exposed(attributes.except(:id)).
+            transform_values {|attribute| object.public_send(attribute.from)},
+          :relationships => exposed(relations).
+            transform_values {|relation| relation.using(self).as_json},
+          :links => {
+            :self => links_self
+          }
+        }.transform_values(&:presence).compact
+      end
+
+      private def exposed(mapping)
+        if selects.any?
+          mapping.
+            select {|_, value| value.visible?(self)}.
+            slice(*selects.dig(type))
+        else
+          mapping.
+            select {|_, value| value.visible?(self)}
+        end
+      end
+
+      def as_json(*)
+        {
+          :links => {
+            :self => links_self
+          },
+          :data => as_data,
+          :included => included
+        }.transform_values(&:presence).compact
+      end
+
+      private def id
+        object.public_send(identifier).to_s
+      end
+
+      def type
+        self.class.configuration.type.to_s
+      end
+
+      private def attributes
+        self.class.configuration.attributes
+      end
+
+      private def origin
+        self.class.configuration.origin
+      end
+
+      private def identifier
+        self.class.configuration.identifier
+      end
+
+      private def relations
+        self.class.configuration.relations
+      end
+
+      def attribute(name)
+        self.class.attribute(name)
+      end
+
+      def relation(name)
+        self.class.relation(name)
+      end
+
+      def links_self
+        Addressable::Template.new(
+          "#{origin}/#{type}/#{object.public_send(identifier)}"
+        ).pattern
+      end
+
+      def selects
+        (@selects || {}).transform_values {|list| list.map(&:to_sym)}
+      end
+
+      def includes
+        @includes || []
+      end
+
+      def context
+        self.class.const_get("Context").new(**@context || {})
+      end
+
+      private def included
+        @included ||= includes.flat_map do |path|
+          path.reduce(self) do |subject, key|
+            if subject.is_a?(Array)
+              subject.map {|related_subject| related_subject.relation(key).for(subject)}
+            else
+              subject.relation(key).for(subject)
+            end
+          end
+        end.map(&:as_data)
+      end
+
+      included do
+        class_eval(&MIXIN_HOOK) unless @abstract_class
+      end
+
+      class_methods do
+        def inherited(object)
+          object.class_eval(&MIXIN_HOOK) unless object.instance_variable_defined?(:@abstract_class)
+        end
+
+        def identifier(value)
+          @identifier = value.to_sym
+        end
+
+        def origin(value)
+          @origin = value
+        end
+
+        def type(value)
+          @type = value.to_sym
+        end
+
+        def has(name, from: name, visible: true)
+          @attributes[name] = Attribute.new(
+            :owner => self,
+            :name => name,
+            :from => from,
+            :visible => visible
+          )
+        end
+
+        def has_one(name, from: name, class_name:, visible: true)
+          @relations[name] = Relation.new(
+            :owner => self,
+            :type => :one,
+            :name => name,
+            :from => from,
+            :class_name => class_name,
+            :visible => visible
+          )
+        end
+
+        def has_many(name, from: name, class_name:, visible: true)
+          @relations[name] = Relation.new(
+            :owner => self,
+            :type => :many,
+            :name => name,
+            :from => from,
+            :class_name => class_name,
+            :visible => visible
+          )
+        end
+
+        def context
+          const_get("Context")
+        end
+
+        def configuration
+          @configuration ||= Configuration.new(
+            :owner => self,
+            :type => @type,
+            :origin => @origin,
+            :identifier => @identifier,
+            :attributes => @attributes,
+            :relations => @relations
+          )
+        end
+
+        def attribute(name)
+          configuration.attributes.fetch(name.to_sym) {raise(Error::ResourceRelationshipNotFound, :name => name, :materializer => self)}
+        end
+
+        def relation(name)
+          configuration.relations.fetch(name.to_sym) {raise(Error::ResourceRelationshipNotFound, :name => name, :materializer => self)}
+        end
+      end
+    end
+  end
+end

data/lib/jsonapi/materializer/resource/attribute.rb

@@ -0,0 +1,49 @@
+module JSONAPI
+  module Materializer
+    module Resource
+      class Attribute
+        include(ActiveModel::Model)
+
+        attr_accessor(:owner)
+        attr_accessor(:name)
+        attr_accessor(:from)
+        attr_accessor(:visible)
+
+        validates_presence_of(:owner)
+        validates_presence_of(:name)
+        validates_presence_of(:from)
+        validate(:visible_callable)
+
+        def initialize(**keyword_arguments)
+          super(**keyword_arguments)
+
+          validate!
+        end
+
+        def for(subject)
+          subject.object.public_send(from)
+        end
+
+        def visible?(subject)
+          return visible if [true, false].include?(visible)
+          return subject.send(visible, self) if visible.is_a?(Symbol)
+          return visible.call(self) if visible.respond_to?(:call)
+
+          true
+        end
+
+        private def materializer_class
+          class_name.constantize
+        end
+
+        private def visible_callable
+          return if [true, false].include?(visible)
+          return if visible.is_a?(Symbol)
+          return if visible.respond_to?(:call)
+
+          errors.add(:visible, "not callable or boolean")
+        end
+      end
+    end
+  end
+end

data/lib/jsonapi/materializer/resource/configuration.rb

@@ -0,0 +1,27 @@
+module JSONAPI
+  module Materializer
+    module Resource
+      class Configuration
+        include(ActiveModel::Model)
+
+        attr_accessor(:owner)
+        attr_accessor(:type)
+        attr_accessor(:origin)
+        attr_accessor(:identifier)
+        attr_accessor(:attributes)
+        attr_accessor(:relations)
+
+        validates_presence_of(:owner)
+        validates_presence_of(:type)
+        validates_presence_of(:origin)
+        validates_presence_of(:identifier)
+
+        def initialize(**keyword_arguments)
+          super(**keyword_arguments)
+
+          validate!
+        end
+      end
+    end
+  end
+end

data/lib/jsonapi/materializer/resource/relation.rb

@@ -0,0 +1,107 @@
+module JSONAPI
+  module Materializer
+    module Resource
+      class Relation
+        include(ActiveModel::Model)
+
+        attr_accessor(:owner)
+        attr_accessor(:name)
+        attr_accessor(:type)
+        attr_accessor(:from)
+        attr_accessor(:class_name)
+        attr_accessor(:visible)
+
+        validates_presence_of(:owner)
+        validates_presence_of(:name)
+        validates_presence_of(:type)
+        validates_presence_of(:from)
+        validates_presence_of(:class_name)
+        validate(:visible_callable)
+
+        def initialize(**keyword_arguments)
+          super(**keyword_arguments)
+
+          validate!
+        end
+
+        def for(subject)
+          @for ||= {}
+          @for[checksum(subject)] ||= case type
+          when :many then
+            unlessing(fetch_relation(subject), -> {subject.includes.any? {|included| included.include?(from.to_s)} || fetch_relation(subject).loaded?}) do |subject|
+              subject.select(:id)
+            end.map do |related_object|
+              materializer_class.new(
+                **subject.raw,
+                :object => related_object
+              )
+            end
+          when :one then
+            if fetch_relation(subject).present?
+              materializer_class.new(
+                **subject.raw,
+                :object => fetch_relation(subject)
+              )
+            end
+          end
+        end
+
+        def visible?(subject)
+          return visible if [true, false].include?(visible)
+          return subject.send(visible, self) if visible.is_a?(Symbol)
+          return visible.call(self) if visible.respond_to?(:call)
+
+          true
+        end
+
+        private def fetch_relation(subject)
+          @fetch_relationship ||= {}
+          @fetch_relationship[checksum(subject)] ||= subject.object.public_send(from)
+        end
+
+        def using(parent)
+          Resource::Relationship.new(:related => self, :parent => parent)
+        end
+
+        def many?
+          type == :many
+        end
+
+        def one?
+          type == :one
+        end
+
+        private def materializer_class
+          class_name.constantize
+        end
+
+        private def visible_callable
+          return if [true, false].include?(visible)
+          return if visible.is_a?(Symbol)
+          return if visible.respond_to?(:call)
+
+          errors.add(:visible, "not callable or boolean")
+        end
+
+        private def unlessing(object, proc)
+          unless proc.call()
+            yield(object)
+          else
+            object
+          end
+        end
+
+        private def checksum(subject)
+          [
+            from,
+            materializer_class,
+            name,
+            owner,
+            subject,
+            type
+          ].hash
+        end
+      end
+    end
+  end
+end