jsonapi-materializer 1.0.0.rc6 → 1.0.0

data/lib/jsonapi/materializer/collection_spec.rb

@@ -1,101 +1,103 @@
+# frozen_string_literal: true
+
 require("spec_helper")
 
 RSpec.describe(JSONAPI::Materializer::Collection) do
-  let(:described_class) {ArticleMaterializer::Collection}
-  let(:collection) {described_class.new(:object => object, :includes => [["comments"], ["author"]])}
+  let(:described_class) { ArticleMaterializer::Collection }
+  let(:collection) { described_class.new(object:, includes: [["comments"], ["author"]]) }
 
   describe("#as_json") do
-    subject {collection.as_json.deep_stringify_keys}
+    subject { collection.as_json.deep_stringify_keys }
 
     before do
-      Account.create!(:id => 9, :name => "Dan Gebhardt", :twitter => "dgeb")
-      Account.create!(:id => 2, :name => "DHH", :twitter => "DHH")
-      Article.create!(:id => 1, :title => "JSON API paints my bikeshed!", :account => Account.find(9))
-      Article.create!(:id => 2, :title => "Rails is Omakase", :account => Account.find(9))
-      Article.create!(:id => 3, :title => "What is JSON:API?", :account => Account.find(9))
-      Comment.create!(:id => 5, :body => "First!", :article => Article.find(1), :account => Account.find(2))
-      Comment.create!(:id => 12, :body => "I like XML better", :article => Article.find(1), :account => Account.find(9))
+      Account.create!(id: 9, name: "Dan Gebhardt", twitter: "dgeb")
+      Account.create!(id: 2, name: "DHH", twitter: "DHH")
+      Article.create!(id: 1, title: "JSON API paints my bikeshed!", account: Account.find(9))
+      Article.create!(id: 2, title: "Rails is Omakase", account: Account.find(9))
+      Article.create!(id: 3, title: "What is JSON:API?", account: Account.find(9))
+      Comment.create!(id: 5, body: "First!", article: Article.find(1), account: Account.find(2))
+      Comment.create!(id: 12, body: "I like XML better", article: Article.find(1), account: Account.find(9))
     end
 
     context("when the list has items") do
-      let(:object) {Kaminari.paginate_array(Article.all).page(1).per(1)}
+      let(:object) { Kaminari.paginate_array(Article.all).page(1).per(1) }
 
       it("has a data key at root with the resources") do
         expect(subject.fetch("data")).to(eq([{
-          "id" => "1",
-          "type" => "articles",
-          "attributes" => {
-            "title" => "JSON API paints my bikeshed!"
-          },
-          "relationships" => {
-            "author" => {
-              "data" => {"id" => "9", "type" => "people"},
-              "links" => {
-                "self" => "http://example.com/articles/1/relationships/author",
-                "related" => "http://example.com/articles/1/author"
-              }
-            },
-            "comments" => {
-              "data" => [
-                {"id" => "5", "type" => "comments"},
-                {"id" => "12", "type" => "comments"}
-              ],
-              "links" => {
-                "self" => "http://example.com/articles/1/relationships/comments",
-                "related" => "http://example.com/articles/1/comments"
-              }
-            }
-          },
-          "links" => {
-            "self" => "http://example.com/articles/1"
-          }
-        }]))
+                                              "id" => "1",
+                                              "type" => "articles",
+                                              "attributes" => {
+                                                "title" => "JSON API paints my bikeshed!"
+                                              },
+                                              "relationships" => {
+                                                "author" => {
+                                                  "data" => { "id" => "9", "type" => "people" },
+                                                  "links" => {
+                                                    "self" => "http://example.com/articles/1/relationships/author",
+                                                    "related" => "http://example.com/articles/1/author"
+                                                  }
+                                                },
+                                                "comments" => {
+                                                  "data" => [
+                                                    { "id" => "5", "type" => "comments" },
+                                                    { "id" => "12", "type" => "comments" }
+                                                  ],
+                                                  "links" => {
+                                                    "self" => "http://example.com/articles/1/relationships/comments",
+                                                    "related" => "http://example.com/articles/1/comments"
+                                                  }
+                                                }
+                                              },
+                                              "links" => {
+                                                "self" => "http://example.com/articles/1"
+                                              }
+                                            }]))
       end
 
       it("has a links key at root with pagination") do
         expect(subject.fetch("links")).to(eq(
-          "self" => "http://example.com/articles",
-          "next" => "http://example.com/articles?page[offset]=2&page[limit]=1",
-          "last" => "http://example.com/articles?page[offset]=3&page[limit]=1"
-        ))
+                                            "self" => "http://example.com/articles",
+                                            "next" => "http://example.com/articles?page[offset]=2&page[limit]=1",
+                                            "last" => "http://example.com/articles?page[offset]=3&page[limit]=1"
+                                          ))
       end
 
       it("has a included key at root with included models") do
         expect(subject.fetch("included")).to(include(
-          {
-            "id" => "5",
-            "type" => "comments",
-            "attributes"=>{"body"=>"First!"},
-            "relationships" => {
-              "author" => {"data" => {"id" => "2", "type" => "people"}, "links" => {"self" => "http://example.com/comments/5/relationships/author", "related" => "http://example.com/comments/5/author"}},
-              "article" => {"data" => {"id" => "1", "type" => "articles"}, "links" => {"self" => "http://example.com/comments/5/relationships/article", "related" => "http://example.com/comments/5/article"}}
-            },
-            "links" => {"self" => "http://example.com/comments/5"}
-          },
-          {
-            "id" => "12",
-            "type" => "comments",
-            "attributes"=>{"body"=>"I like XML better"},
-            "relationships" => {
-              "author" => {"data" => {"id" => "9", "type" => "people"}, "links" => {"self" => "http://example.com/comments/12/relationships/author", "related" => "http://example.com/comments/12/author"}},
-              "article" => {"data" => {"id" => "1", "type" => "articles"}, "links" => {"self" => "http://example.com/comments/12/relationships/article", "related" => "http://example.com/comments/12/article"}}
-            },
-            "links" => {"self" => "http://example.com/comments/12"}
-          },
-          {
-            "id" => "9",
-            "type" => "people",
-            "attributes"=>{"name"=>"Dan Gebhardt"},
-            "relationships" => {
-              "comments" => {"data" => [{"id" => "12", "type" => "comments"}], "links" => {"self" => "http://example.com/people/9/relationships/comments", "related" => "http://example.com/people/9/comments"}},
-              "articles" => {
-                "data" => [{"id" => "1", "type" => "articles"}, {"id" => "2", "type" => "articles"}, {"id" => "3", "type" => "articles"}],
-                "links" => {"self" => "http://example.com/people/9/relationships/articles", "related" => "http://example.com/people/9/articles"}
-              }
-            },
-            "links" => {"self" => "http://example.com/people/9"}
-          }
-        ))
+                                               {
+                                                 "id" => "5",
+                                                 "type" => "comments",
+                                                 "attributes" => { "body" => "First!" },
+                                                 "relationships" => {
+                                                   "author" => { "data" => { "id" => "2", "type" => "people" }, "links" => { "self" => "http://example.com/comments/5/relationships/author", "related" => "http://example.com/comments/5/author" } },
+                                                   "article" => { "data" => { "id" => "1", "type" => "articles" }, "links" => { "self" => "http://example.com/comments/5/relationships/article", "related" => "http://example.com/comments/5/article" } }
+                                                 },
+                                                 "links" => { "self" => "http://example.com/comments/5" }
+                                               },
+                                               {
+                                                 "id" => "12",
+                                                 "type" => "comments",
+                                                 "attributes" => { "body" => "I like XML better" },
+                                                 "relationships" => {
+                                                   "author" => { "data" => { "id" => "9", "type" => "people" }, "links" => { "self" => "http://example.com/comments/12/relationships/author", "related" => "http://example.com/comments/12/author" } },
+                                                   "article" => { "data" => { "id" => "1", "type" => "articles" }, "links" => { "self" => "http://example.com/comments/12/relationships/article", "related" => "http://example.com/comments/12/article" } }
+                                                 },
+                                                 "links" => { "self" => "http://example.com/comments/12" }
+                                               },
+                                               {
+                                                 "id" => "9",
+                                                 "type" => "people",
+                                                 "attributes" => { "name" => "Dan Gebhardt" },
+                                                 "relationships" => {
+                                                   "comments" => { "data" => [{ "id" => "12", "type" => "comments" }], "links" => { "self" => "http://example.com/people/9/relationships/comments", "related" => "http://example.com/people/9/comments" } },
+                                                   "articles" => {
+                                                     "data" => [{ "id" => "1", "type" => "articles" }, { "id" => "2", "type" => "articles" }, { "id" => "3", "type" => "articles" }],
+                                                     "links" => { "self" => "http://example.com/people/9/relationships/articles", "related" => "http://example.com/people/9/articles" }
+                                                   }
+                                                 },
+                                                 "links" => { "self" => "http://example.com/people/9" }
+                                               }
+                                             ))
       end
     end
   end

data/lib/jsonapi/materializer/configuration.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module JSONAPI
   module Materializer
     class Configuration

data/lib/jsonapi/materializer/controller.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module JSONAPI
   module Materializer
     module Controller

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module JSONAPI
   module Materializer
     class Error

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module JSONAPI
   module Materializer
     class Error

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module JSONAPI
   module Materializer
     class Error

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module JSONAPI
   module Materializer
     class Error

data/lib/jsonapi/materializer/error.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module JSONAPI
   module Materializer
     class Error < StandardError

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module JSONAPI
   module Materializer
     module Resource

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module JSONAPI
   module Materializer
     module Resource

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module JSONAPI
   module Materializer
     module Resource
@@ -25,32 +27,28 @@ module JSONAPI
         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
-
-        private def fetch_relation(subject)
-          @fetch_relationship ||= {}
-          @fetch_relationship[checksum(subject)] ||= subject.object.public_send(from)
+                                      when :many
+                                        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
+                                        if fetch_relation(subject).present?
+                                          materializer_class.new(
+                                            **subject.raw,
+                                            object: fetch_relation(subject)
+                                          )
+                                        end
+                                      end
         end
+        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity
 
         def using(parent)
-          Resource::Relationship.new(:related => self, :parent => parent)
+          Resource::Relationship.new(related: self, parent:)
         end
 
         def many?
@@ -61,15 +59,20 @@ module JSONAPI
           type == :one
         end
 
+        private def fetch_relation(subject)
+          @fetch_relationship ||= {}
+          @fetch_relationship[checksum(subject)] ||= subject.object.public_send(from)
+        end
+
         private def materializer_class
           class_name.constantize
         end
 
         private def unlessing(object, proc)
-          unless proc.call()
-            yield(object)
-          else
+          if proc.call
             object
+          else
+            yield(object)
           end
         end
 

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module JSONAPI
   module Materializer
     module Resource
@@ -18,12 +20,12 @@ module JSONAPI
 
         def as_json(*)
           {
-            :data => data,
-            :links => {
-              :self => links_self,
-              :related => links_related
+            data:,
+            links: {
+              self: links_self,
+              related: links_related
             },
-            :meta => {}
+            meta: {}
           }.transform_values(&:presence).compact
         end
 
@@ -33,31 +35,32 @@ module JSONAPI
           ).pattern
         end
 
-        private def links_related
+        def links_related
           Addressable::Template.new(
             "#{parent.links_self}/#{related.name}"
           ).pattern
         end
 
-        private def data
+        def data
           return if related_parent_materializer.blank?
 
           @data ||= if related.many?
-            related_parent_materializer.map do |child|
-              {
-                :id => child.attribute("id").for(child).to_s,
-                :type => child.type.to_s
-              }
-            end
-          else
-            {
-              :id => related_parent_materializer.attribute("id").for(related_parent_materializer).to_s,
-              :type => related_parent_materializer.type.to_s
-            }
-          end
+                      related_parent_materializer.map do |child|
+                        {
+                          id: child.attribute("id").for(child).to_s,
+                          type: child.type.to_s
+                        }
+                      end
+                    else
+                      {
+                        id: related_parent_materializer.attribute("id").for(related_parent_materializer).to_s,
+                        type: related_parent_materializer.type.to_s
+                      }
+                    end
         end
+        # rubocop:enable Metrics/AbcSize
 
-        private def related_parent_materializer
+        def related_parent_materializer
           related.for(parent)
         end
       end

data/lib/jsonapi/materializer/resource.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module JSONAPI
   module Materializer
     module Resource
@@ -9,11 +11,11 @@ module JSONAPI
       extend(ActiveSupport::Concern)
       include(ActiveModel::Model)
 
-      MIXIN_HOOK = ->(*) do
+      MIXIN_HOOK = lambda do |*|
         @attributes = {}
         @relations = {}
 
-        unless const_defined?("Collection")
+        unless const_defined?(:Collection)
           self::Collection = Class.new do
             include(JSONAPI::Materializer::Collection)
           end
@@ -42,60 +44,33 @@ module JSONAPI
 
       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
+          id:,
+          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.slice(*selects.dig(type))
-        else
-          mapping
-        end
-      end
+      # rubocop:enable Metrics/AbcSize
 
       def as_json(*)
         {
-          :links => {
-            :self => links_self
+          links: {
+            self: links_self
           },
-          :data => as_data,
-          :included => included
+          data: as_data,
+          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
@@ -111,31 +86,20 @@ module JSONAPI
       end
 
       def selects
-        (@selects || {}).transform_values {|list| list.map(&:to_sym)}
+        (@selects || {}).transform_values { |list| list.map(&:to_sym) }
       end
 
       def includes
         @includes || []
       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)
+          super
           object.class_eval(&MIXIN_HOOK) unless object.instance_variable_defined?(:@abstract_class)
         end
 
@@ -153,51 +117,95 @@ module JSONAPI
 
         def has(name, from: name)
           @attributes[name] = Attribute.new(
-            :owner => self,
-            :name => name,
-            :from => from
+            owner: self,
+            name:,
+            from:
           )
         end
 
-        def has_one(name, from: name, class_name:)
+        # rubocop:disable Naming/PredicateName
+        def has_one(name, class_name:, from: name)
           @relations[name] = Relation.new(
-            :owner => self,
-            :type => :one,
-            :name => name,
-            :from => from,
-            :class_name => class_name
+            owner: self,
+            type: :one,
+            name:,
+            from:,
+            class_name:
           )
         end
+        # rubocop:enable Naming/PredicateName
 
-        def has_many(name, from: name, class_name:)
+        # rubocop:disable Naming/PredicateName
+        def has_many(name, class_name:, from: name)
           @relations[name] = Relation.new(
-            :owner => self,
-            :type => :many,
-            :name => name,
-            :from => from,
-            :class_name => class_name
+            owner: self,
+            type: :many,
+            name:,
+            from:,
+            class_name:
           )
         end
+        # rubocop:enable Naming/PredicateName
 
         def configuration
           @configuration ||= Configuration.new(
-            :owner => self,
-            :type => @type,
-            :origin => @origin,
-            :identifier => @identifier,
-            :attributes => @attributes,
-            :relations => @relations
+            owner: self,
+            type: @type,
+            origin: @origin,
+            identifier: @identifier,
+            attributes: @attributes,
+            relations: @relations
           )
         end
 
         def attribute(name)
-          configuration.attributes.fetch(name.to_sym) {raise(Error::ResourceAttributeNotFound, :name => name, :materializer => self)}
+          configuration.attributes.fetch(name.to_sym) { raise(Error::ResourceAttributeNotFound, name:, materializer: self) }
         end
 
         def relation(name)
-          configuration.relations.fetch(name.to_sym) {raise(Error::ResourceRelationshipNotFound, :name => name, :materializer => self)}
+          configuration.relations.fetch(name.to_sym) { raise(Error::ResourceRelationshipNotFound, name:, materializer: self) }
         end
       end
+
+      private def exposed(mapping)
+        if selects.any?
+          mapping.slice(*selects[type])
+        else
+          mapping
+        end
+      end
+
+      private def id
+        object.public_send(identifier).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
+
+      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
     end
   end
 end