jsonapi-object-mapper 0.6.5 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0ef9bc7d28430b0e48b01bcc3ec63e1298209ad9d1e6daaed479ca9710d4677e
-  data.tar.gz: d02434eb5eef6e593c6d98d39f64892d61d37c76314c7bf728d9e7a597a99c22
+  metadata.gz: c55b670a2ffe1d7d8d64a77103e3652694ad29076072cda48899f65228fb8232
+  data.tar.gz: 5e597a8fe9650ef363ce6bf6902d3b5de7b3b316a49b50107e57018191c93e57
 SHA512:
-  metadata.gz: f7ef9678bc19aa674fb35ae2033fd3c43c1f1a7c9ea174d1fa460795728468ae558c946bfafbb8f7788705b8a77caeb1dc86a13075d33309f06eaf9b3123c0fc
-  data.tar.gz: 800ea410fee0c3452aee0a5767805b48f1bc90b77a3abd8fa74049461f104cdf4480717cf6e54c19f5388a4fecb3ccaf033aa56a084d392816bc182e47ac581f
+  metadata.gz: 7b037952245ea17ff6baed1cde1fe3d17620c29d268be9df0230ece3d48f51ac1b92ca9d99b9f21ae563a3e1e5d6cde23825e8b9a7294d21f8844bc7fb3ddad6
+  data.tar.gz: 187087f89ba2fd1d2fa18faaca2ea9f2f2312875466b24fe4593ff933d964ccd36b5eefdb8e114f60b3afe04636730cb2f7642ec62845936cc950189ccf7a2ab

data/.rubocop.yml

@@ -59,6 +59,9 @@ Style/ClassAndModuleChildren:
 Style/Documentation:
   Enabled: false
 
+Naming/PredicateName:
+  Enabled: false
+
 Style/Lambda:
   Enabled: false
 

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    jsonapi-object-mapper (0.6.5)
+    jsonapi-object-mapper (0.7.0)
       oj (~> 3.0)
 
 GEM
@@ -13,9 +13,9 @@ GEM
     diff-lcs (1.3)
     jaro_winkler (1.5.1)
     method_source (0.9.0)
-    oj (3.6.3)
+    oj (3.6.4)
     parallel (1.12.1)
-    parser (2.5.1.0)
+    parser (2.5.1.2)
       ast (~> 2.4.0)
     powerpack (0.1.2)
     pry (0.11.3)
@@ -39,10 +39,10 @@ GEM
       diff-lcs (>= 1.2.0, < 2.0)
       rspec-support (~> 3.7.0)
     rspec-support (3.7.1)
-    rubocop (0.57.2)
+    rubocop (0.58.1)
       jaro_winkler (~> 1.5.1)
       parallel (~> 1.10)
-      parser (>= 2.5)
+      parser (>= 2.5, != 2.5.1.1)
       powerpack (~> 0.1)
       rainbow (>= 2.2.2, < 4.0)
       ruby-progressbar (~> 1.7)

data/README.md

@@ -1,3 +1,5 @@
+[![Gem Version](https://badge.fury.io/rb/jsonapi-object-mapper.svg)](https://badge.fury.io/rb/jsonapi-object-mapper) [![Build Status](https://travis-ci.com/GeorgeKaraszi/jsonapi-object-mapper.svg?branch=master)](https://travis-ci.com/GeorgeKaraszi/jsonapi-object-mapper) [![Maintainability](https://api.codeclimate.com/v1/badges/6eef293ed23cf92a4c1a/maintainability)](https://codeclimate.com/github/GeorgeKaraszi/jsonapi-object-mapper/maintainability)
+
 # JsonapiObjectMapper
 
 Deserialize's raw or pre-hashed JsonAPI objects into plan ruby objects as well as embeds any included relational resources.

data/lib/jsonapi-object-mapper/deserialize/collection.rb

@@ -11,8 +11,8 @@ module JsonAPIObjectMapper
       attr_accessor :collection_data
 
       def initialize(parser, klass:)
-        raise InvalidResource, "Must provide a valid resource klass" unless klass.is_a?(Class)
-        raise InvalidParser, "Must provide a parsed document" unless parser.is_a?(JsonAPIObjectMapper::Parser::Document)
+        raise InvalidResource unless klass.is_a?(Class)
+        raise InvalidParser   unless parser.is_a?(JsonAPIObjectMapper::Parser::Document)
         @errors            = parser.errors
         @collection_data   =
           if document_invalid?
@@ -26,6 +26,14 @@ module JsonAPIObjectMapper
         freeze
       end
 
+      def to_hash
+        @collection_data.map(&:to_hash)
+      end
+
+      def [](index)
+        @collection_data[index]
+      end
+
       def each
         @collection_data.each do |data|
           yield data

data/lib/jsonapi-object-mapper/deserialize/dsl.rb

@@ -3,7 +3,8 @@
 module JsonAPIObjectMapper
   module Deserialize
     module DSL
-      DEFAULT_BLOCK = proc { |value| value }
+      DEFAULT_BLOCK  = proc { |value| value }
+      HAS_MANY_BLOCK = proc { |values| values.is_a?(Collection) ? values : Array(values) }
 
       def self.extended(klass)
         klass.include ClassMethods
@@ -28,14 +29,39 @@ module JsonAPIObjectMapper
         attributes_names.each(&method(:attribute))
       end
 
-      def has_one(relationship_name, embed_with: nil, &block) # rubocop:disable Naming/PredicateName
-        rel_blocks[relationship_name.to_s]  = block || DEFAULT_BLOCK
-        rel_options[relationship_name.to_s] = embed_with unless embed_with.nil?
+      def has_one(relationship_name, **options, &block)
+        rel_options_process!(relationship_name, options)
+        rel_has_one_blocks[relationship_name.to_s] = block || DEFAULT_BLOCK
         define_method(relationship_name.to_sym) { fetch_relationship(relationship_name) }
       end
-      alias has_many has_one
       alias belongs_to has_one
 
+      def has_many(relationship_name, **options, &block)
+        rel_options_process!(relationship_name, options)
+        rel_has_many_blocks[relationship_name.to_s] = block || HAS_MANY_BLOCK
+        define_method(relationship_name.to_sym) { fetch_relationship(relationship_name) }
+      end
+
+      def kind_of_resource?(klass)
+        !klass.nil? && klass < Resource
+      end
+
+      private
+
+      def rel_options_process!(relationship_name, **options)
+        embed_klass = options.delete(:embed_with)
+        return if embed_klass.nil?
+
+        embed_klass = embed_klass.is_a?(String) ? Kernel.const_get(embed_klass) : embed_klass
+        if kind_of_resource?(embed_klass)
+          rel_options[relationship_name.to_s] = { embed_with: embed_klass }
+        else
+          raise InvalidEmbedKlass
+        end
+      rescue NameError # Rescue from `Kernel.const_get/1`
+        raise InvalidEmbedKlass
+      end
+
       module ClassMethods
         def initialize(*args)
           @_class_attributes    = {}
@@ -66,29 +92,45 @@ module JsonAPIObjectMapper
         end
 
         def assign_attribute(key, value)
-          block = self.class.attr_blocks[key.to_s] || DEFAULT_BLOCK
+          block = self.class.attr_blocks.fetch(key.to_s, DEFAULT_BLOCK)
           @_class_attributes[key.to_s] = block.call(value)
         end
 
-        def assign_relationship(key, value)
-          block             = self.class.rel_blocks[key.to_s] || DEFAULT_BLOCK
-          rel_embed_class   = self.class.rel_options[key.to_s]
-          rel_value         = @includes.fetch(value)
-
-          @_class_relationships[key.to_s] =
-            if rel_value != value && rel_embed_class.respond_to?(:embed!)
-              block.call(rel_embed_class.embed!(rel_value))
-            else
-              block.call(rel_value)
-            end
+        def assign_has_one_relationship(key, value)
+          key                        = key.to_s
+          block                      = self.class.rel_has_one_blocks.fetch(key, DEFAULT_BLOCK)
+          rel_embed_class            = self.class.rel_options.dig(key, :embed_with)
+          rel_value                  = embed!(rel_embed_class, @includes.fetch(value))
+          @_class_relationships[key] = block.call(rel_value)
+        end
+
+        def assign_has_many_relationship(key, values)
+          key                        = key.to_s
+          block                      = self.class.rel_has_many_blocks.fetch(key, HAS_MANY_BLOCK)
+          rel_embed_class            = self.class.rel_options.dig(key, :embed_with)
+          rel_values                 = values.map { |value| @includes.fetch(value) }
+          @_class_relationships[key] = block.call(embed!(rel_embed_class, rel_values))
         end
 
-        def include_attribute?(attribute_name)
+        def attribute_defined?(attribute_name)
           self.class.attr_blocks.key?(attribute_name)
         end
 
-        def include_relationship?(rel_name)
-          self.class.rel_blocks.key?(rel_name)
+        def has_one_defined?(rel_name)
+          self.class.rel_has_one_blocks.key?(rel_name)
+        end
+
+        def has_many_defined?(rel_name)
+          self.class.rel_has_many_blocks.key?(rel_name)
+        end
+
+        def kind_of_resource?(rel_embed_class)
+          self.class.kind_of_resource?(rel_embed_class)
+        end
+
+        def embed!(rel_embed_class, attributes)
+          return attributes unless self.class.kind_of_resource?(rel_embed_class)
+          rel_embed_class.load("data" => attributes)
         end
       end
     end

data/lib/jsonapi-object-mapper/deserialize/resource.rb

@@ -11,22 +11,28 @@ module JsonAPIObjectMapper
       extend DSL
 
       class << self
-        attr_accessor :rel_blocks, :rel_options, :attr_blocks, :id_block, :type_block
+        attr_accessor :rel_has_one_blocks, :rel_has_many_blocks, :rel_options, :attr_blocks, :id_block, :type_block
       end
       instance_variable_set("@attr_blocks", {})
-      instance_variable_set("@rel_blocks", {})
+      instance_variable_set("@rel_has_one_blocks", {})
+      instance_variable_set("@rel_has_many_blocks", {})
       instance_variable_set("@rel_options", {})
 
       def self.inherited(klass)
         super
         klass.instance_variable_set("@attr_blocks", attr_blocks.dup)
-        klass.instance_variable_set("@rel_blocks", rel_blocks.dup)
+        klass.instance_variable_set("@rel_has_one_blocks", rel_has_one_blocks.dup)
+        klass.instance_variable_set("@rel_has_many_blocks", rel_has_many_blocks.dup)
         klass.instance_variable_set("@rel_options", rel_options.dup)
         klass.instance_variable_set("@id_block", id_block)
         klass.instance_variable_set("@type_block", type_block)
       end
 
       def self.call(document)
+        load(document)
+      end
+
+      def self.load(document)
         parser = JsonAPIObjectMapper::Parser::Document.new(document)
         if parser.document["data"].is_a?(Array) || parser.invalid?
           Collection.new(parser, klass: self)
@@ -35,14 +41,9 @@ module JsonAPIObjectMapper
         end
       end
 
-      def self.embed!(attributes)
-        parser = JsonAPIObjectMapper::Parser::Document.new("attributes" => attributes)
-        new(parser)
-      end
-
       def initialize(parser, document: nil)
         super()
-        raise InvalidParser, "Must provide a parsed document" unless parser.is_a?(JsonAPIObjectMapper::Parser::Document)
+        raise InvalidParser unless parser.is_a?(JsonAPIObjectMapper::Parser::Document)
         @errors = parser.errors
 
         if document_valid?
@@ -75,28 +76,35 @@ module JsonAPIObjectMapper
       end
 
       def deserialize_id_type!
-        assign_attribute("id", self.class.id_block.call(@id))       if self.class.id_block
-        assign_attribute("type", self.class.type_block.call(@type)) if self.class.type_block
+        # Initialize ID and Type attribute blocks if one does not exist
+        self.class.id   unless self.class.id_block
+        self.class.type unless self.class.type_block
+
+        assign_attribute("id", self.class.id_block.call(@id))
+        assign_attribute("type", self.class.type_block.call(@type))
       end
 
       def deserialize_attributes!
         return if @attributes.empty?
-        @attributes.each_pair(&method(:initialize_attribute))
+        @attributes.each_pair(&method(:new_attribute))
       end
 
       def deserialize_relationships!
         return if @relationships.empty?
-        @relationships.each_pair(&method(:initialize_relationship))
+        @relationships.each_pair(&method(:new_relationship))
       end
 
-      def initialize_attribute(attr_name, attr_value)
-        return unless include_attribute?(attr_name)
+      def new_attribute(attr_name, attr_value)
+        return unless attribute_defined?(attr_name)
         assign_attribute(attr_name, attr_value)
       end
 
-      def initialize_relationship(rel_type, rel_value)
-        return unless include_relationship?(rel_type)
-        assign_relationship(rel_type, rel_value["data"])
+      def new_relationship(rel_type, rel_value)
+        if has_one_defined?(rel_type)
+          assign_has_one_relationship(rel_type, rel_value["data"])
+        elsif has_many_defined?(rel_type)
+          assign_has_many_relationship(rel_type, rel_value["data"])
+        end
       end
     end
   end

data/lib/jsonapi-object-mapper/exceptions.rb

@@ -2,8 +2,23 @@
 
 module JsonAPIObjectMapper
   class InvalidResource < StandardError
+    def initialize(msg = nil)
+      msg ||= "The deserializer class must be an inherited `JsonAPIObjectMapper::Deserialize::Resource` klass"
+      super
+    end
   end
 
   class InvalidParser < StandardError
+    def initialize(msg = nil)
+      msg ||= "Must provide a parsed `JsonAPIObjectMapper::Parser::Document` klass-document"
+      super
+    end
+  end
+
+  class InvalidEmbedKlass < StandardError
+    def initialize(msg = nil)
+      msg ||= "The `embed_with: ...` option, must be a inherited `JsonAPIObjectMapper::Deserialize::Resource` klass"
+      super
+    end
   end
 end

data/lib/jsonapi-object-mapper/parser/document.rb

@@ -11,7 +11,7 @@ module JsonAPIObjectMapper
       attr_accessor :document, :includes
 
       def initialize(document)
-        @document = document.is_a?(Hash) ? document : ::Oj.load(document)
+        @document = (document.is_a?(String) ? ::Oj.load(document) : document).freeze
         @includes = IncludedResources.load(@document["included"])
         @errors   = deserialize_errors!.freeze
         freeze

data/lib/jsonapi-object-mapper/parser/included_resources.rb

@@ -16,8 +16,8 @@ module JsonAPIObjectMapper
       def initialize(included_resources = [])
         included_resources ||= []
         @resource = included_resources.each_with_object({}) do |include, hash|
-          hash[format_key(include)] = include["attributes"]
-        end
+          hash[format_key(include)] = include
+        end.freeze
 
         freeze
       end

data/lib/jsonapi-object-mapper/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module JsonAPIObjectMapper
-  VERSION = "0.6.5"
+  VERSION = "0.7.0"
 end

data/spec/deserialize/resource_spec.rb

@@ -3,7 +3,7 @@
 require "spec_helper"
 
 module JsonAPIObjectMapper
-  module Deserialize
+  module Deserialize # rubocop:disable Metrics/ModuleLength
     RSpec.describe Resource do
       describe "Attributes" do
         let(:payload) do
@@ -39,7 +39,7 @@ module JsonAPIObjectMapper
         end
       end
 
-      describe "Relationships" do
+      describe ".has_one Relationship" do
         let(:payload) do
           {
             "relationships" => {
@@ -53,7 +53,7 @@ module JsonAPIObjectMapper
           }
         end
 
-        context "Has included Resource" do
+        context "Has one included Resource" do
           let(:included_payload) do
             payload.merge(
               "included" => [
@@ -72,7 +72,7 @@ module JsonAPIObjectMapper
             end
 
             actual = klass.call(included_payload)
-            expect(actual.photo).to eq("image" => "good_day_sir.jpg")
+            expect(actual.photo).to include("attributes" => { "image" => "good_day_sir.jpg" })
           end
 
           it "Should Resolve and decode the resource as the embedded relationship class" do
@@ -100,7 +100,7 @@ module JsonAPIObjectMapper
             expect(actual.photo).to eq("id" => "1", "type" => "photo")
           end
 
-          it "Should set the default relationship values if no includes can be found" do
+          it "Should assign attributes that exist from the included resource" do
             photo_klass = Class.new(described_class) do
               attribute :image
             end
@@ -109,9 +109,85 @@ module JsonAPIObjectMapper
               has_one :photo, embed_with: photo_klass
             end
 
-            actual = core_klass.call(payload)
-            expect(actual.photo).to be_a(Hash)
-            expect(actual.photo).to eq("id" => "1", "type" => "photo")
+            actual = core_klass.load(payload)
+            expect(actual.photo).to be_a(photo_klass)
+            expect(actual.photo.id).to eq("1")
+            expect(actual.photo.type).to eq("photo")
+            expect(actual.photo.image).to be_nil
+          end
+        end
+      end
+
+      describe ".has_many Relationships" do
+        let(:payload) do
+          {
+            "relationships" => {
+              "photos" => {
+                "data" => [
+                  { "type" => "photo", "id" => "1" },
+                  { "type" => "photo", "id" => "99" },
+                ],
+              },
+            },
+          }
+        end
+
+        context "Has many included resources" do
+          let(:included_payload) do
+            payload.merge(
+              "included" => [
+                {
+                  "id" => "1",
+                  "type" => "photo",
+                  "attributes" => { "image" => "good_day_sir.jpg" },
+                },
+                {
+                  "id" => "99",
+                  "type" => "photo",
+                  "attributes" => { "image" => "i_said_good_day!.jpg" },
+                },
+              ],
+            )
+          end
+
+          it "Should store a collection of included values" do
+            klass = Class.new(described_class) do
+              has_many :photos
+            end
+
+            actual = klass.load(included_payload)
+            expect(actual.photos).to be_a(Array)
+            expect(actual.photos.first["id"]).to eq("1")
+            expect(actual.photos.first["type"]).to eq("photo")
+
+            expect(actual.photos.last["id"]).to eq("99")
+            expect(actual.photos.last["type"]).to eq("photo")
+          end
+
+          it "Should resolve the embed_with option to a collection of parsed results" do
+            photo_klass = Class.new(described_class)
+            klass       = Class.new(described_class) do
+              has_many :photos, embed_with: photo_klass
+            end
+
+            actual = klass.load(included_payload)
+            expect(actual.photos).to be_a(Collection)
+            expect(actual.photos[0].id).to eq("1")
+            expect(actual.photos[1].id).to eq("99")
+          end
+        end
+
+        context "Has no included resources" do
+          it "Should set the hash of the unresolved type" do
+            klass = Class.new(described_class) do
+              has_many :photos
+            end
+
+            actual = klass.load(payload)
+            expect(actual.photos).to be_a(Array)
+            expect(actual.photos.first).to be_a(Hash)
+            expect(actual.photos.first["id"]).to eq("1")
+            expect(actual.photos.last["id"]).to eq("99")
           end
         end
       end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: jsonapi-object-mapper
 version: !ruby/object:Gem::Version
-  version: 0.6.5
+  version: 0.7.0
 platform: ruby
 authors:
 - George Protacio-Karaszi
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-07-08 00:00:00.000000000 Z
+date: 2018-07-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: oj