jsonapi-realizer 6.0.0.rc2 → 6.0.0

data/lib/jsonapi/realizer/resource.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module JSONAPI
   module Realizer
     module Resource
@@ -8,11 +10,11 @@ module JSONAPI
       extend(ActiveSupport::Concern)
       include(ActiveModel::Model)
 
-      MIXIN_HOOK = ->(*) do
+      MIXIN_HOOK = lambda do |*|
         @attributes = {}
         @relations = {}
 
-        unless const_defined?("Context")
+        unless const_defined?(:Context)
           self::Context = Class.new do
             include(JSONAPI::Realizer::Context)
 
@@ -25,8 +27,8 @@ module JSONAPI
         end
 
         validates_presence_of(:intent)
-        validates_presence_of(:parameters, :allow_empty => true)
-        validates_presence_of(:headers, :allow_empty => true)
+        validates_presence_of(:parameters, allow_empty: true)
+        validates_presence_of(:headers, allow_empty: true)
 
         identifier(JSONAPI::Realizer.configuration.default_identifier)
 
@@ -38,7 +40,7 @@ module JSONAPI
       attr_accessor(:parameters)
       attr_accessor(:headers)
       attr_writer(:context)
-      attr_accessor(:scope)
+      attr_writer(:scope)
 
       def initialize(**keyword_arguments)
         super(**keyword_arguments)
@@ -46,41 +48,30 @@ module JSONAPI
         context.validate!
         validate!
 
-        if filtering?
-          @scope = adapter.filtering(scope, filters)
-        end
+        @scope = adapter.filtering(scope, filters) if filtering?
 
-        if include?
-          @scope = adapter.include_relationships(scope, includes)
-        end
+        @scope = adapter.include_relationships(scope, includes) if include?
 
-        if sorting?
-          @scope = adapter.sorting(scope, sorts)
-        end
+        @scope = adapter.sorting(scope, sorts) if sorting?
 
-        if paginate?
-          @scope = adapter.paginate(scope, *pagination)
-        end
+        @scope = adapter.paginate(scope, *pagination) if paginate?
 
-        if writing? && data?
-          adapter.write_attributes(object, attributes)
-          adapter.write_relationships(object, relationships)
-        end
+        adapter.write_attributes(object, attributes) if writing? && data? && attributes?
+
+        return unless writing? && data? && relationships?
+
+        adapter.write_relationships(object, relationships)
       end
 
       def to_hash
-        @native ||= {
-          :pagination => if paginate? then pagination end,
-          :selects => if selects? then selects end,
-          :includes => if include? then includes end,
-          :object => object
+        @to_hash ||= {
+          pagination: (pagination if paginate?),
+          selects: (selects if selects?),
+          includes: (includes if include?),
+          object:
         }.compact
       end
 
-      private def writing?
-        [:create, :update].include?(intent)
-      end
-
       def paginate?
         parameters.key?("page") && (parameters.fetch("page").key?("limit") || parameters.fetch("page").key?("offset"))
       end
@@ -98,19 +89,19 @@ module JSONAPI
 
       def sorts
         @sorts ||= parameters.
-          # {sort: "name,-age,accounts.created_at,-accounts.updated_at"}
-          fetch("sort").
-          # "name,-age,accounts.created_at,-accounts.updated_at"
-          split(",").
-          # ["name", "-age", "accounts.created_at", "-accounts.updated_at"]
-          map do |token|
-            if token.start_with?("-") then [token.sub(/^-/, "").underscore, "-"] else [token.underscore, "+"] end
-          end.
-          # [["name", "+"], ["age", "-"], ["accounts.created_at", "+"], ["accounts.updated_at", "-"]]
-          map do |(path, direction)|
-            [if path.include?(".") then path.split(".") else [self.class.configuration.type, path] end, direction]
-          end
-          # [[["accounts", "name"], "+"], [["accounts", "age"], "-"], [["accounts", "created_at"], "+"], [["accounts", "updated_at"], "-"]]
+                   # {sort: "name,-age,accounts.created_at,-accounts.updated_at"}
+                   fetch("sort").
+                   # "name,-age,accounts.created_at,-accounts.updated_at"
+                   split(",").
+                   # ["name", "-age", "accounts.created_at", "-accounts.updated_at"]
+                   map do |token|
+                     token.start_with?("-") ? [token.sub(/^-/, "").underscore, "-"] : [token.underscore, "+"]
+                   end.
+                   # [["name", "+"], ["age", "-"], ["accounts.created_at", "+"], ["accounts.updated_at", "-"]]
+                   map do |(path, direction)|
+          [path.include?(".") ? path.split(".") : [self.class.configuration.type, path], direction]
+        end
+        # [[["accounts", "name"], "+"], [["accounts", "age"], "-"], [["accounts", "created_at"], "+"], [["accounts", "updated_at"], "-"]]
       end
 
       def filtering?
@@ -119,11 +110,11 @@ module JSONAPI
 
       def filters
         @filters ||= parameters.
-          # {"filter" => {"full-name" => "Abby Marquardt", "email" => "amado@goldner.com"}}
-          fetch("filter").
-          # {"full-name" => "Abby Marquardt", "email" => "amado@goldner.com"}
-          transform_keys(&:underscore)
-          # {"full_name" => "Abby Marquardt", "email" => "amado@goldner.com"}
+                     # {"filter" => {"full-name" => "Abby Marquardt", "email" => "amado@goldner.com"}}
+                     fetch("filter").
+                     # {"full-name" => "Abby Marquardt", "email" => "amado@goldner.com"}
+                     transform_keys(&:underscore)
+        # {"full_name" => "Abby Marquardt", "email" => "amado@goldner.com"}
       end
 
       def include?
@@ -132,30 +123,30 @@ module JSONAPI
 
       def includes
         @includes ||= parameters.
-          # {"include" => "active-photographer.photographs,comments,comments.author"}
-          fetch("include").
-          # "active-photographer.photographs,comments,comments.author"
-          split(/\s*,\s*/).
-          # ["active-photographer.photographs", "comments", "comments.author"]
-          map {|chain| chain.split(".")}.
-          # [["active-photographer", "photographs"], ["comments"], ["comments", "author"]]
-          map {|list| list.map(&:underscore)}.
-          # [["active_photographer", "photographs"], ["comments"], ["comments", "author"]]
-          map do |relationship_chain|
-            # This walks down the path of relationships and normalizes thenm to
-            # their defined "as", which lets us expose AccountRealizer#name, but that actually
-            # references Account#full_name.
-            relationship_chain.reduce([[], self.class]) do |(normalized_relationship_chain, realizer_class), relationship_link|
+                      # {"include" => "active-photographer.photographs,comments,comments.author"}
+                      fetch("include").
+                      # "active-photographer.photographs,comments,comments.author"
+                      split(/\s*,\s*/).
+                      # ["active-photographer.photographs", "comments", "comments.author"]
+                      map { |chain| chain.split(".") }.
+                      # [["active-photographer", "photographs"], ["comments"], ["comments", "author"]]
+                      map { |list| list.map(&:underscore) }.
+                      # [["active_photographer", "photographs"], ["comments"], ["comments", "author"]]
+                      map do |relationship_chain|
+          # This walks down the path of relationships and normalizes thenm to
+          # their defined "as", which lets us expose AccountRealizer#name, but that actually
+          # references Account#full_name.
+          relationship_chain.reduce([[], self.class]) do |(normalized_relationship_chain, realizer_class), relationship_link|
+            [
               [
-                [
-                  *normalized_relationship_chain,
-                  realizer_class.relation(relationship_link).as
-                ],
-                realizer_class.relation(relationship_link).realizer_class
-              ]
-            end.first
-          end
-          # [["account", "photographs"], ["comments"], ["comments", "account"]]
+                *normalized_relationship_chain,
+                realizer_class.relation(relationship_link).as
+              ],
+              realizer_class.relation(relationship_link).realizer_class
+            ]
+          end.first
+        end
+        # [["account", "photographs"], ["comments"], ["comments", "account"]]
       end
 
       def selects?
@@ -164,99 +155,53 @@ module JSONAPI
 
       def selects
         @selects ||= parameters.
-          # {"fields" => {"articles" => "title,body,sub-text", "people" => "name"}}
-          fetch("fields").
-          # {"articles" => "title,body,sub-text", "people" => "name"}
-          transform_keys(&:underscore).
-          # {"articles" => "title,body,sub-text", "people" => "name"}
-          transform_values {|value| value.split(/\s*,\s*/)}.
-          # {"articles" => ["title", "body", "sub-text"], "people" => ["name"]}
-          transform_values {|value| value.map(&:underscore)}
-          # {"articles" => ["title", "body", "sub_text"], "people" => ["name"]}
-      end
-
-      private def data?
-        parameters.key?("data")
-      end
-
-      private def data
-        @data ||= parameters.fetch("data")
-      end
-
-      private def type
-        return unless data.key?("type")
-
-        @type ||= data.fetch("type")
+                     # {"fields" => {"articles" => "title,body,sub-text", "people" => "name"}}
+                     fetch("fields").
+                     # {"articles" => "title,body,sub-text", "people" => "name"}
+                     transform_keys(&:underscore).
+                     # {"articles" => "title,body,sub-text", "people" => "name"}
+                     transform_values { |value| value.split(/\s*,\s*/) }.
+                     # {"articles" => ["title", "body", "sub-text"], "people" => ["name"]}
+                     transform_values { |value| value.map(&:underscore) }
+        # {"articles" => ["title", "body", "sub_text"], "people" => ["name"]}
       end
 
       def attributes
         return unless data.key?("attributes")
 
-        @attributes ||= data.
-          fetch("attributes").
-          transform_keys(&:underscore).
-          transform_keys{|key| attribute(key).as}
+        @attributes ||= data
+                        .fetch("attributes")
+                        .transform_keys(&:underscore)
+                        .transform_keys { |key| attribute(key).as }
       end
 
       def relationships
         return unless data.key?("relationships")
 
-        @relationships ||= data.
-          fetch("relationships").
-          transform_keys(&:underscore).
-          map(&method(:as_relationship)).to_h.
-          transform_keys{|key| relation(key).as}
-      end
-
-      private def scope
-        @scope ||= adapter.find_many(@scope || model_class)
+        @relationships ||= data
+                           .fetch("relationships")
+                           .transform_keys(&:underscore)
+                           .map(&method(:as_relationship)).to_h
+                           .transform_keys { |key| relation(key).as }
       end
 
       def object
         @object ||= case intent
-        when :create
-          scope.new
-        when :show, :update, :destroy
-          adapter.find_one(scope, parameters.fetch("id"))
-        else
-          scope
-        end
+                    when :create
+                      scope.new
+                    when :show, :update, :destroy
+                      adapter.find_one(scope, parameters.fetch("id"))
+                    else
+                      scope
+                    end
       end
 
       def intent
         @intent.to_sym
       end
 
-      private def as_relationship(name, value)
-        data = value.fetch("data")
-
-        relation_configuration = relation(name).realizer_class.configuration
-
-        if data.is_a?(Array)
-          [name, relation_configuration.adapter.find_many(relation_configuration.model_class, {id: data.map {|value| value.fetch("id")}})]
-        else
-          [name, relation_configuration.adapter.find_one(relation_configuration.model_class, data.fetch("id"))]
-        end
-      end
-
-      private def attribute(name)
-        self.class.attribute(name)
-      end
-
-      private def relation(name)
-        self.class.relation(name)
-      end
-
-      private def adapter
-        self.class.configuration.adapter
-      end
-
-      private def model_class
-        self.class.configuration.model_class
-      end
-
       def context
-        self.class.const_get("Context").new(**@context || {})
+        self.class.const_get(:Context).new(**@context || {})
       end
 
       included do
@@ -265,6 +210,7 @@ module JSONAPI
 
       class_methods do
         def inherited(object)
+          super
           object.class_eval(&MIXIN_HOOK) unless object.instance_variable_defined?(:@abstract_class)
         end
 
@@ -273,62 +219,126 @@ module JSONAPI
         end
 
         def type(value, class_name:, adapter:)
-          @type ||= value.to_s
-          @model_class ||= class_name.constantize
-          @adapter ||= JSONAPI::Realizer::Adapter.new(interface: adapter)
+          @type = value.to_s
+          @model_class = class_name.constantize
+          @adapter = JSONAPI::Realizer::Adapter.new(interface: adapter)
         end
 
         def has(name, as: name)
           @attributes[name] ||= Attribute.new(
-            :name => name,
-            :as => as,
-            :owner => self
+            name:,
+            as:,
+            owner: self
           )
         end
 
-        def has_one(name, as: name, class_name:)
+        # rubocop:disable Naming/PredicateName
+        def has_one(name, class_name:, as: name)
           @relations[name] ||= Relation.new(
-            :owner => self,
-            :type => :one,
-            :name => name,
-            :as => as,
-            :realizer_class_name => class_name
+            owner: self,
+            type: :one,
+            name:,
+            as:,
+            realizer_class_name: class_name
           )
         end
+        # rubocop:enable Naming/PredicateName
 
-        def has_many(name, as: name, class_name:)
+        # rubocop:disable Naming/PredicateName
+        def has_many(name, class_name:, as: name)
           @relations[name] ||= Relation.new(
-            :owner => self,
-            :type => :many,
-            :name => name,
-            :as => as,
-            :realizer_class_name => class_name
+            owner: self,
+            type: :many,
+            name:,
+            as:,
+            realizer_class_name: class_name
           )
         end
+        # rubocop:enable Naming/PredicateName
 
         def context
-          const_get("Context")
+          const_get(:Context)
         end
 
         def configuration
-          @configuration ||= Configuration.new({
-            :owner => self,
-            :type => @type,
-            :model_class => @model_class,
-            :adapter => @adapter,
-            :attributes => @attributes,
-            :relations => @relations
-          })
+          @configuration ||= Configuration.new(
+            owner: self,
+            type: @type,
+            model_class: @model_class,
+            adapter: @adapter,
+            attributes: @attributes,
+            relations: @relations
+          )
         end
 
         def attribute(name)
-          configuration.attributes.fetch(name.to_sym){raise(Error::ResourceAttributeNotFound, name: name, realizer: self)}
+          configuration.attributes.fetch(name.to_sym) { raise(Error::ResourceAttributeNotFound, name:, realizer: self) }
         end
 
         def relation(name)
-          configuration.relations.fetch(name.to_sym){raise(Error::ResourceRelationshipNotFound, name: name, realizer: self)}
+          configuration.relations.fetch(name.to_sym) { raise(Error::ResourceRelationshipNotFound, name:, realizer: self) }
+        end
+      end
+
+      private def writing?
+        %i[create update].include?(intent)
+      end
+
+      private def data?
+        parameters.key?("data")
+      end
+
+      private def data
+        @data ||= parameters.fetch("data")
+      end
+
+      private def type
+        return unless data.key?("type")
+
+        @type ||= data.fetch("type")
+      end
+
+      private def attributes?
+        data.key?("attributes")
+      end
+
+      private def relationships?
+        data.key?("relationships")
+      end
+
+      private def scope
+        @scope ||= adapter.find_many(@scope || model_class)
+      end
+
+      private def as_relationship(name, value)
+        return [name, nil] if value.nil?
+
+        data = value.fetch("data")
+
+        relation_configuration = relation(name).realizer_class.configuration
+
+        if data.is_a?(Array)
+          [name, relation_configuration.adapter.find_many(relation_configuration.model_class, { id: data.map { |value| value.fetch("id") } })]
+        else
+          [name, relation_configuration.adapter.find_one(relation_configuration.model_class, data.fetch("id"))]
         end
       end
+
+      private def attribute(name)
+        self.class.attribute(name)
+      end
+
+      private def relation(name)
+        self.class.relation(name)
+      end
+
+      private def adapter
+        self.class.configuration.adapter
+      end
+
+      private def model_class
+        self.class.configuration.model_class
+      end
     end
   end
 end

data/lib/jsonapi/realizer/resource_spec.rb

@@ -1,14 +1,16 @@
+# frozen_string_literal: true
+
 require("spec_helper")
 
 RSpec.describe(JSONAPI::Realizer::Resource) do
-  let(:resource_class) {PhotoRealizer}
-  let(:resource) {resource_class.new(intent: intent, parameters: parameters, headers: headers)}
+  let(:resource_class) { PhotoRealizer }
+  let(:resource) { resource_class.new(intent:, parameters:, headers:) }
 
   describe "#as_native" do
-    let(:subject) {resource}
+    subject { resource }
 
     context "when accepting the right type, when creating with data, with spares fields, and includes" do
-      let(:intent) {:create}
+      let(:intent) { :create }
       let(:parameters) do
         {
           "include" => "photographer",
@@ -41,23 +43,62 @@ RSpec.describe(JSONAPI::Realizer::Resource) do
       end
 
       before do
-        Account.create!(:id => 9, :name => "Dan Gebhardt", :twitter => "dgeb")
+        Account.create!(id: 9, name: "Dan Gebhardt", twitter: "dgeb")
       end
 
       it "object is a Photo" do
-        expect(subject.object).to be_kind_of(Photo)
+        expect(subject.object).to be_a(Photo)
       end
 
       it "object isn't saved" do
-        expect(subject.object).to_not be_persisted()
+        expect(subject.object).not_to be_persisted
       end
 
       it "object has the right attributes" do
         expect(subject.object).to have_attributes(
-          :title => "Ember Hamster",
-          :src => "http://example.com/images/productivity.png"
+          title: "Ember Hamster",
+          src: "http://example.com/images/productivity.png"
         )
       end
+
+      it "has a photographer" do
+        expect(subject.object.photographer).not_to be_nil
+      end
+    end
+
+    context "when specifying nil relationship" do
+      let(:intent) { :update }
+      let(:parameters) do
+        {
+          "id" => "11",
+          "data" => {
+            "id" => "11",
+            "type" => "photos",
+            "relationships" => {
+              "photographer" => nil
+            }
+          }
+        }
+      end
+      let(:headers) do
+        {
+          "Accept" => "application/vnd.api+json",
+          "Content-Type" => "application/vnd.api+json"
+        }
+      end
+
+      before do
+        account = Account.create!(id: 9, name: "Dan Gebhardt", twitter: "dgeb")
+        Photo.create!(id: 11, photographer: account, title: "Ember Hamster", src: "http://example.com/images/productivity.png")
+      end
+
+      it "object is a Photo" do
+        expect(subject.object).to be_a(Photo)
+      end
+
+      it "clears relationship on realizing nil" do
+        expect(subject.object.photographer).to be_nil
+      end
     end
   end
 end

data/lib/jsonapi/realizer/version.rb

@@ -1,5 +1,7 @@
+# frozen_string_literal: true
+
 module JSONAPI
   module Realizer
-    VERSION = "6.0.0.rc2"
+    VERSION = "6.0.0"
   end
 end

data/lib/jsonapi/realizer.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require("ostruct")
 require("addressable")
 require("active_model")
@@ -7,7 +9,7 @@ require("active_support/core_ext/string")
 require("active_support/core_ext/module")
 
 module JSONAPI
-  MEDIA_TYPE = "application/vnd.api+json" unless const_defined?("MEDIA_TYPE")
+  MEDIA_TYPE = "application/vnd.api+json" unless const_defined?(:MEDIA_TYPE)
 
   module Realizer
     require_relative("realizer/version")
@@ -16,10 +18,10 @@ module JSONAPI
     require_relative("realizer/controller")
 
     @configuration ||= Configuration.new(
-      :default_invalid_content_type_exception => JSONAPI::Realizer::Error::InvalidContentTypeHeader,
-      :default_missing_content_type_exception => JSONAPI::Realizer::Error::MissingContentTypeHeader,
-      :default_identifier => :id,
-      :adapter_mappings => {}
+      default_invalid_content_type_exception: JSONAPI::Realizer::Error::InvalidContentTypeHeader,
+      default_missing_content_type_exception: JSONAPI::Realizer::Error::MissingContentTypeHeader,
+      default_identifier: :id,
+      adapter_mappings: {}
     )
 
     require_relative("realizer/adapter")

data/lib/jsonapi/realizer_spec.rb

@@ -1,29 +1,3 @@
-require "spec_helper"
+# frozen_string_literal: true
 
-RSpec.describe JSONAPI::Realizer do
-  let(:parameters) {
-    {
-      "data" => {
-        "type" => "photos",
-        "attributes" => {
-          "title" => "Ember Hamster",
-          "src" => "http://example.com/images/productivity.png"
-        },
-        "relationships" => {
-          "photographer" => {
-            "data" => {
-              "type" => "people",
-              "id" => "9"
-            }
-          }
-        }
-      }
-    }
-  }
-  let(:headers) {
-    {
-      "Accept" => "application/vnd.api+json",
-      "Content-Type" => "application/vnd.api+json"
-    }
-  }
-end
+require "spec_helper"

data/lib/jsonapi-realizer.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module JSONAPI
   require_relative "jsonapi/realizer"
 end