jsonapi-deserializable 0.1.1.beta3 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f3004871b4ea0f17caaeab2c1f000c632337c486
-  data.tar.gz: 4eb06414674e45c45fc3d276ffa966bc97313ae7
+  metadata.gz: '00948aee890ce50979d9e79091d3d773c718c81d'
+  data.tar.gz: be1b26548249485868b080a05d232119ac5c7f71
 SHA512:
-  metadata.gz: fdf14b9d40b30ea331a01b10212be3b5582785e45634ab7e49e2d81957a4408af6ce838d05dc27e9d86828a704cef1a2eb23e5331d2c13d4fa131829c6a4c03e
-  data.tar.gz: ee5342f0d5444e68773e504353000090dc71117fba3eee3a0af21399c32836085eab9f8076dd70a2cfe54385a85f9140c692007199f12b70ef60315ca76cad64
+  metadata.gz: 1f74445bc44fef0931df10075cf8cdd359c91c8c178c4ba2a59318168094f18b9ca5ca30f131f3a6d401497d41c33cd3c628f79069294dae41cc168f5de2bfa6
+  data.tar.gz: a2bff5fd5dd4442935088c08208f400d0c79fc08363c2b8742df0d70f33f979883b051bacc460d1b3ba2cf9c5d31e622c399cd2bf34051f8dd04bfa1fee129d4

data/README.md

@@ -5,100 +5,14 @@ hashes.
 ## Status
 
 [![Gem Version](https://badge.fury.io/rb/jsonapi-deserializable.svg)](https://badge.fury.io/rb/jsonapi-deserializable)
-[![Build Status](https://secure.travis-ci.org/beauby/jsonapi-deserializable.svg?branch=master)](http://travis-ci.org/beauby/jsonapi-deserializable?branch=master)
+[![Build Status](https://secure.travis-ci.org/jsonapi-rb/jsonapi-deserializable.svg?branch=master)](http://travis-ci.org/jsonapi-rb/deserializable?branch=master)
+[![codecov](https://codecov.io/gh/jsonapi-rb/jsonapi-deserializable/branch/master/graph/badge.svg)](https://codecov.io/gh/jsonapi-rb/deserializable)
+[![Gitter chat](https://badges.gitter.im/gitterHQ/gitter.png)](https://gitter.im/jsonapi-rb/Lobby)
 
-## Installation
-```ruby
-# In Gemfile
-gem 'jsonapi-deserializable'
-```
-then
-```
-$ bundle
-```
-or manually via
-```
-$ gem install jsonapi-deserializable
-```
 
-## Usage
+## Usage and documentation
 
-First, require the gem:
-```ruby
-require 'jsonapi/deserializable'
-```
-
-Then, define some resource/relationship classes:
-
-### Resources
-
-```ruby
-class DeserializableCreatePost < JSONAPI::Deserializable::Resource
-  type
-  attribute :title
-  attribute :date { |date| field date: DateTime.parse(date) }
-  has_one :author do |rel, id, type|
-    field author_id: id
-    field author_type: type
-  end
-  has_many :comments do |rel, ids, types|
-    field comment_ids: ids
-    field comment_types: types.map do |type|
-      camelize(singularize(type))
-    end
-  end
-end
-```
-Finally, build your hash from the deserializable resource:
-```ruby
-payload = {
-  'data' => {
-    'id' => '1',
-    'type' => 'posts',
-    'attributes' => {
-      'title' => 'Title',
-      'date' => '2016-01-10 02:30:00'
-    },
-    'relationships' => {
-      'author' => {
-        'data' => { 'type' => 'users', 'id' => '1337' }
-      },
-      'comments' => {
-        'data' => [
-          { 'type' => 'comments', 'id' => '123' },
-          { 'type' => 'comments', 'id' => '234' },
-          { 'type' => 'comments', 'id' => '345' }
-        ]
-      }
-    }
-  }
-}
-
-DeserializableCreateUser.(payload)
-# => {
-#      id: '1',
-#      title: 'Title',
-#      date: #<DateTime: 2016-01-10T02:30:00+00:00 ((2457398j,9000s,0n),+0s,2299161j)>,
-#      author_id: '1337',
-#      author_type: 'users',
-#      comment_ids: ['123', '234', '345']
-#      comment_types: ['Comment', 'Comment', 'Comment']
-#    }
-```
-
-### Relationships
-
-```
-class DeserializablePostComments < JSONAPI::Deserializable::Relationship
-  has_many do |rel, ids, types|
-    field comment_ids: ids
-    field comment_types: types.map do |ri|
-      camelize(singularize(type))
-    end
-    field comments_meta: rel['meta']
-  end
-end
-```
+See [jsonapi-rb.org/guides/deserialization](http://jsonapi-rb.org/guides/deserialization).
 
 ## License
 

data/lib/jsonapi/deserializable/relationship.rb

@@ -1,15 +1,17 @@
-require 'jsonapi/deserializable/relationship_dsl'
+require 'jsonapi/deserializable/relationship/dsl'
+require 'jsonapi/parser/relationship'
 
 module JSONAPI
   module Deserializable
     class Relationship
-      include RelationshipDSL
+      extend DSL
 
       class << self
         attr_accessor :has_one_block, :has_many_block
       end
 
       def self.inherited(klass)
+        super
         klass.has_one_block  = has_one_block
         klass.has_many_block = has_many_block
       end
@@ -19,32 +21,47 @@ module JSONAPI
       end
 
       def initialize(payload)
+        Parser::Relationship.parse!(payload)
         @document = payload
         @data = payload['data']
         deserialize!
+        freeze
       end
 
-      def to_h
+      def to_hash
         @hash
       end
+      alias to_h to_hash
 
       private
 
       def deserialize!
-        @hash = {}
-        if @data.is_a?(Array)
-          ids = @data.map { |ri| ri['id'] }
-          types = @data.map { |ri| ri['type'] }
-          instance_exec(@document, ids, types, &self.class.has_many_block)
+        @hash =
+          if @data.is_a?(Array)
+            deserialize_has_many
+          elsif @data.nil? || @data.is_a?(Hash)
+            deserialize_has_one
+          end
+      end
+
+      def deserialize_has_one
+        id = @data && @data['id']
+        type = @data && @data['type']
+        if self.class.has_one_block
+          self.class.has_one_block.call(@document, id, type)
         else
-          id = @data && @data['id']
-          type = @data && @data['type']
-          instance_exec(@document, id, type, &self.class.has_one_block)
+          { id: id, type: type }
         end
       end
 
-      def field(hash)
-        @hash.merge!(hash)
+      def deserialize_has_many
+        ids = @data.map { |ri| ri['id'] }
+        types = @data.map { |ri| ri['type'] }
+        if self.class.has_many_block
+          self.class.has_many_block.call(@document, ids, types)
+        else
+          { ids: ids, types: types }
+        end
       end
     end
   end

data/lib/jsonapi/deserializable/relationship/dsl.rb

@@ -0,0 +1,15 @@
+module JSONAPI
+  module Deserializable
+    class Relationship
+      module DSL
+        def has_one(&block)
+          self.has_one_block = block
+        end
+
+        def has_many(&block)
+          self.has_many_block = block
+        end
+      end
+    end
+  end
+end

data/lib/jsonapi/deserializable/resource.rb

@@ -1,34 +1,49 @@
-require 'jsonapi/deserializable/resource_dsl'
+require 'jsonapi/deserializable/resource/configuration'
+require 'jsonapi/deserializable/resource/dsl'
+require 'jsonapi/parser/resource'
 
 module JSONAPI
   module Deserializable
     class Resource
-      include ResourceDSL
+      extend DSL
 
       class << self
-        attr_accessor :type_block, :id_block
-        attr_accessor :attr_blocks
-        attr_accessor :has_one_rel_blocks, :has_many_rel_blocks
+        attr_accessor :type_block, :id_block, :attr_blocks,
+                      :has_one_rel_blocks, :has_many_rel_blocks,
+                      :configuration
       end
 
-      self.attr_blocks = {}
-      self.has_one_rel_blocks = {}
+      @class_cache = {}
+
+      self.configuration       = Configuration.new
+      self.attr_blocks         = {}
+      self.has_one_rel_blocks  = {}
       self.has_many_rel_blocks = {}
 
       def self.inherited(klass)
         super
-        klass.type_block  = type_block
-        klass.id_block    = id_block
-        klass.attr_blocks = attr_blocks.dup
+        klass.configuration       = configuration.dup
+        klass.type_block          = type_block
+        klass.id_block            = id_block
+        klass.attr_blocks         = attr_blocks.dup
         klass.has_one_rel_blocks  = has_one_rel_blocks.dup
         klass.has_many_rel_blocks = has_many_rel_blocks.dup
       end
 
+      def self.configure
+        yield(configuration)
+      end
+
+      def self.[](name)
+        @class_cache[name] ||= Class.new(self)
+      end
+
       def self.call(payload)
         new(payload).to_h
       end
 
       def initialize(payload)
+        Parser::Resource.parse!(payload)
         @document = payload
         @data = @document['data']
         @type = @data['type']
@@ -36,75 +51,105 @@ module JSONAPI
         @attributes    = @data['attributes'] || {}
         @relationships = @data['relationships'] || {}
         deserialize!
+        freeze
       end
 
-      def to_h
+      def to_hash
         @hash
       end
+      alias to_h to_hash
+
+      attr_reader :reverse_mapping
 
       private
 
-      def deserialize!
-        @hash = {}
-        deserialize_type!
-        deserialize_id!
-        deserialize_attrs!
-        deserialize_rels!
+      def configuration
+        self.class.configuration
       end
 
-      def deserialize_type!
-        return unless @type && self.class.type_block
-        instance_exec(@type, &self.class.type_block)
+      def register_mappings(keys, path)
+        keys.each do |k|
+          @reverse_mapping[k] = path
+        end
       end
 
-      def deserialize_id!
-        return unless @id && self.class.id_block
-        instance_exec(@id, &self.class.id_block)
+      def deserialize!
+        @reverse_mapping = {}
+        hashes = [deserialize_type, deserialize_id,
+                  deserialize_attrs, deserialize_rels]
+        @hash = hashes.reduce({}, :merge)
       end
 
-      def deserialize_attrs!
-        self.class.attr_blocks.each do |attr, block|
-          next unless @attributes.key?(attr)
-          instance_exec(@attributes[attr], &block)
-        end
+      def deserialize_type
+        block = self.class.type_block || configuration.default_type
+        hash = block.call(@type)
+        register_mappings(hash.keys, '/data/type')
+        hash
       end
 
-      def deserialize_rels!
-        deserialize_has_one_rels!
-        deserialize_has_many_rels!
+      def deserialize_id
+        return {} unless @id
+        block = self.class.id_block || configuration.default_id
+        hash  = block.call(@id)
+        register_mappings(hash.keys, '/data/id')
+        hash
       end
 
-      def deserialize_has_one_rels!
-        self.class.has_one_rel_blocks.each do |key, block|
-          rel = @relationships[key]
-          next unless rel && (rel['data'].nil? || rel['data'].is_a?(Hash))
-          deserialize_has_one_rel!(rel, &block)
-        end
+      def deserialize_attrs
+        @attributes
+          .map { |key, val| deserialize_attr(key, val) }
+          .reduce({}, :merge)
       end
 
-      def deserialize_has_one_rel!(rel, &block)
-        id = rel['data'] && rel['data']['id']
-        type = rel['data'] && rel['data']['type']
-        instance_exec(rel, id, type, &block)
+      def deserialize_attr(key, val)
+        hash = if self.class.attr_blocks.key?(key)
+                 self.class.attr_blocks[key].call(val)
+               else
+                 configuration.default_attribute.call(key, val)
+               end
+        register_mappings(hash.keys, "/data/attributes/#{key}")
+        hash
       end
 
-      def deserialize_has_many_rels!
-        self.class.has_many_rel_blocks.each do |key, block|
-          rel = @relationships[key]
-          next unless rel && rel['data'].is_a?(Array)
-          deserialize_has_many_rel!(rel, &block)
-        end
+      def deserialize_rels
+        @relationships
+          .map { |key, val| deserialize_rel(key, val) }
+          .reduce({}, :merge)
       end
 
-      def deserialize_has_many_rel!(rel, &block)
-        ids = rel['data'].map { |ri| ri['id'] }
-        types = rel['data'].map { |ri| ri['type'] }
-        instance_exec(rel, ids, types, &block)
+      def deserialize_rel(key, val)
+        hash = if val['data'].is_a?(Array)
+                 deserialize_has_many_rel(key, val)
+               else
+                 deserialize_has_one_rel(key, val)
+               end
+        register_mappings(hash.keys, "/data/relationships/#{key}")
+        hash
       end
 
-      def field(hash)
-        @hash.merge!(hash)
+      # rubocop: disable Metrics/AbcSize
+      def deserialize_has_one_rel(key, val)
+        id   = val['data'] && val['data']['id']
+        type = val['data'] && val['data']['type']
+        if self.class.has_one_rel_blocks.key?(key)
+          self.class.has_one_rel_blocks[key].call(val, id, type)
+        else
+          configuration.default_has_one.call(key, val, id, type)
+        end
+      end
+      # rubocop: enable Metrics/AbcSize
+
+      # rubocop: disable Metrics/AbcSize
+      def deserialize_has_many_rel(key, val)
+        ids   = val['data'].map { |ri| ri['id'] }
+        types = val['data'].map { |ri| ri['type'] }
+        if self.class.has_many_rel_blocks.key?(key)
+          self.class.has_many_rel_blocks[key].call(val, ids, types)
+        else
+          configuration.default_has_many.call(key, val, ids, types)
+        end
       end
+      # rubocop: enable Metrics/AbcSize
     end
   end
 end

data/lib/jsonapi/deserializable/resource/configurable.rb

@@ -0,0 +1,17 @@
+require 'jsonapi/deserializable/resource/configuration'
+
+module JSONAPI
+  module Deserializable
+    module Configurable
+      def self.included(klass)
+        klass.class_eval do
+          extend ClassMethods
+          include InstanceMethods
+        end
+      end
+      module ClassMethods
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+module JSONAPI
+  module Deserializable
+    class Resource
+      class Configuration
+        DEFAULT_TYPE_BLOCK = proc { |t| { type: t } }
+        DEFAULT_ID_BLOCK   = proc { |i| { id: i } }
+        DEFAULT_ATTR_BLOCK = proc { |k, v| { k.to_sym => v } }
+        DEFAULT_HAS_ONE_BLOCK = proc do |k, _, i, t|
+          { "#{k}_id".to_sym => i, "#{k}_type".to_sym => t }
+        end
+        DEFAULT_HAS_MANY_BLOCK = proc do |k, _, i, t|
+          { "#{k}_ids".to_sym => i, "#{k}_types".to_sym => t }
+        end
+
+        attr_accessor :default_type, :default_id, :default_attribute,
+                      :default_has_one, :default_has_many
+
+        def initialize
+          self.default_type       = DEFAULT_TYPE_BLOCK
+          self.default_id         = DEFAULT_ID_BLOCK
+          self.default_attribute  = DEFAULT_ATTR_BLOCK
+          self.default_has_one    = DEFAULT_HAS_ONE_BLOCK
+          self.default_has_many   = DEFAULT_HAS_MANY_BLOCK
+        end
+      end
+    end
+  end
+end

data/lib/jsonapi/deserializable/resource/dsl.rb

@@ -1,76 +1,26 @@
 module JSONAPI
   module Deserializable
-    module ResourceDSL
-      attr_accessor :field_blocks, :validations
-
-      def required(&block)
-        add_validations!(FieldList.new(:required, &block).to_h)
-      end
-
-      def optional(&block)
-        add_validations!(FieldList.new(:optional, &block).to_h)
-      end
-
-      def id
-        field_blocks[:id] = proc { @data['id'] }
-      end
-
-      def field(key, &block)
-        field_blocks[key] = block
-      end
-
-      def attribute(key, opts = {})
-        hash_key = (opts[:key] || key).to_s
-        field_blocks[key] = proc { @attributes[hash_key] }
-      end
-
-      def has_many_ids(key, opts = {})
-        hash_key = (opts[:key] || key).to_s
-        field_blocks[key] = proc do
-          @relationships[hash_key]['data'].map { |ri| ri['id'] }
+    class Resource
+      module DSL
+        def type(&block)
+          self.type_block = block
         end
-      end
 
-      def has_many_types(key, opts = {})
-        hash_key = (opts[:key] || key).to_s
-        field_blocks[key] = proc do
-          @relationships[hash_key]['data'].map { |ri| ri['type'] }
+        def id(&block)
+          self.id_block = block
         end
-      end
-
-      def has_many_ids(key, opts = {})
-        hash_key = (opts[:key] || key).to_s
-        @relationships[hash_key]['data']['id']
-      end
-
-      def has_many_ids(key, opts = {})
-        hash_key = (opts[:key] || key).to_s
-        @relationships[hash_key]['data']['type']
-      end
-
-      self.field_blocks = {}
-      self.validations = {}
 
-      def self.inherited(klass)
-        super
-        klass.field_blocks = field_blocks.dup
-        klass.validations = Marshal.load(Marshal.dump(validations))
-      end
+        def attribute(key, &block)
+          attr_blocks[key.to_s] = block
+        end
 
-      private
+        def has_one(key, &block)
+          has_one_rel_blocks[key.to_s] = block
+        end
 
-      def add_validations!(hash)
-        validations[:permitted] = hash[:permitted] if hash[:permitted]
-        validations[:required] = hash[:required] if hash[:required]
-        return unless hash[:types]
-        validations[:types] ||= {}
-        if hash[:types][:primary]
-          validations[:types][:primary] = hash[:types][:primary]
+        def has_many(key, &block)
+          has_many_rel_blocks[key.to_s] = block
         end
-        return unless hash[:types][:relationships]
-        validations[:types][:relationships] ||= {}
-        validations[:types][:relationships]
-          .merge!(hash[:types][:relationships])
       end
     end
   end

metadata

@@ -1,29 +1,43 @@
 --- !ruby/object:Gem::Specification
 name: jsonapi-deserializable
 version: !ruby/object:Gem::Version
-  version: 0.1.1.beta3
+  version: 0.1.1
 platform: ruby
 authors:
 - Lucas Hosseini
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-10-25 00:00:00.000000000 Z
+date: 2016-12-02 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: jsonapi-parser
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.1.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.1.1
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.9'
+        version: '11.3'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.9'
+        version: '11.3'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -38,8 +52,21 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.4'
-description: DSL for validating incoming JSON API payloads and building custom objects
-  out of them.
+- !ruby/object:Gem::Dependency
+  name: codecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+description: DSL for deserializing incoming JSON API payloads into custom hashes.
 email: lucas.hosseini@gmail.com
 executables: []
 extensions: []
@@ -48,11 +75,12 @@ files:
 - README.md
 - lib/jsonapi/deserializable.rb
 - lib/jsonapi/deserializable/relationship.rb
-- lib/jsonapi/deserializable/relationship_dsl.rb
+- lib/jsonapi/deserializable/relationship/dsl.rb
 - lib/jsonapi/deserializable/resource.rb
+- lib/jsonapi/deserializable/resource/configurable.rb
+- lib/jsonapi/deserializable/resource/configuration.rb
 - lib/jsonapi/deserializable/resource/dsl.rb
-- lib/jsonapi/deserializable/resource_dsl.rb
-homepage: https://github.com/beauby/jsonapi-deserializable
+homepage: https://github.com/jsonapi-rb/jsonapi-deserializable
 licenses:
 - MIT
 metadata: {}
@@ -67,13 +95,13 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">"
+  - - ">="
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.1
+rubygems_version: 2.6.8
 signing_key: 
 specification_version: 4
-summary: Deserialization of JSONAPI payloads.
+summary: Deserialize JSON API payloads.
 test_files: []

data/lib/jsonapi/deserializable/relationship_dsl.rb

@@ -1,21 +0,0 @@
-module JSONAPI
-  module Deserializable
-    module RelationshipDSL
-      def self.included(base)
-        base.extend(ClassMethods)
-      end
-
-      module ClassMethods
-        def has_one(&block)
-          block ||= proc { |rel| field key.to_sym => rel }
-          self.has_one_block = block
-        end
-
-        def has_many(&block)
-          block ||= proc { |rel| field key.to_sym => rel }
-          self.has_many_block = block
-        end
-      end
-    end
-  end
-end

data/lib/jsonapi/deserializable/resource_dsl.rb

@@ -1,39 +0,0 @@
-module JSONAPI
-  module Deserializable
-    module ResourceDSL
-      def self.included(base)
-        base.extend(ClassMethods)
-      end
-
-      module ClassMethods
-        def type(&block)
-          block ||= proc { |type| field type: type }
-          self.type_block = block
-        end
-
-        def id(&block)
-          block ||= proc { |id| field id: id }
-          self.id_block = block
-        end
-
-        def attribute(key, options = {}, &block)
-          unless block
-            options[:key] ||= key.to_sym
-            block = proc { |attr| field key => attr }
-          end
-          attr_blocks[key.to_s] = block
-        end
-
-        def has_one(key, &block)
-          block ||= proc { |rel| field key.to_sym => rel }
-          has_one_rel_blocks[key.to_s] = block
-        end
-
-        def has_many(key, &block)
-          block ||= proc { |rel| field key.to_sym => rel }
-          has_many_rel_blocks[key.to_s] = block
-        end
-      end
-    end
-  end
-end