jsonapi-serializable 0.1.1.beta2 → 0.1.1.beta3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9d7beafa6258df4dd44fa02cc22d7a62b8f0e2d0
-  data.tar.gz: fa7223c5647bd81486ec1066e13345a96311081a
+  metadata.gz: 1a382b6d5802f167908d0d6ee82605a7a52d43a0
+  data.tar.gz: 9c9211218919e4a05e74b010cbc9a5ad51c6533e
 SHA512:
-  metadata.gz: e041bc9ebe1a08d945eb721baf612d70166de3cda15a310de8ba860d3f9bb7cd0dc72c2b40a6bf682c7568a0635bf796ed9ebf3676edd47d93ce4c01fcd96e3c
-  data.tar.gz: fd83b712198356d829a7db4b10e2a831d8843a151cfaab7c3a573985a9f8005b2a78f113e0dfbf0b520ca443b18f4194f9635616a8229edf28da847bbbe737a6
+  metadata.gz: bf14811ff7b926f43b45c9cf49032d3fc0c0fe507d4c446d2108fd948de2c5c782cba5b3e90bfe5e6893ee0ef18dcddaf6c91de9e7052445fae25f1b747f65e0
+  data.tar.gz: 14e585466ae7124d51c0d7562e52fbff0982f91025ed71ad9f6a01e1100379b241e1ccea9248d2ebe84a273bdf50d020671b41a80c672f819226c4cfdc0c9a69

data/README.md

@@ -1,11 +1,25 @@
 # jsonapi-serializable
 Ruby gem for building [JSON API](http://jsonapi.org) resources to be rendered by
-the [jsonapi-renderer](https://github.com/beauby/jsonapi) gem.
+the [jsonapi-renderer](https://github.com/jsonapi-rb/renderer) gem.
 
 ## Status
 
 [![Gem Version](https://badge.fury.io/rb/jsonapi-serializable.svg)](https://badge.fury.io/rb/jsonapi-serializable)
-[![Build Status](https://secure.travis-ci.org/beauby/jsonapi-serializable.svg?branch=master)](http://travis-ci.org/beauby/jsonapi-serializable?branch=master)
+[![Build Status](https://secure.travis-ci.org/jsonapi-rb/serializable.svg?branch=master)](http://travis-ci.org/jsonapi-rb/serializable?branch=master)
+
+## Table of Contents
+
+  - [Installation](#installation)
+  - [Usage](#usage)
+    - [Example for Model-based Resources](#example-for-model-based-resources)
+    - [Example for General Resources](#example-for-general-resources)
+  - [Documentation](#documentation)
+    - [`JSONAPI::Serializable::Resource` DSL](#jsonapiserializableresource-dsl)
+    - [`JSONAPI::Serializable::Model` DSL](#jsonapiserializablemodel-dsl)
+    - [`JSONAPI::Serializable::Relationship` DSL](#jsonapiserializablerelationship-dsl)
+    - [`JSONAPI::Serializable::Link` DSL](#jsonapiserializablelink-dsl)
+    - [`JSONAPI::Serializable::Error` DSL](#jsonapiserializableerror-dsl)
+  - [License](#license)
 
 ## Installation
 ```ruby
@@ -30,23 +44,21 @@ require 'jsonapi/serializable'
 
 Then, define some resource classes:
 
-### For model-based resources
+### Example for Model-based Resources
 
 For resources that are simple representations of models, the DSL is simplified:
 
 ```ruby
-class PostResource < JSONAPI::Serializable::Resource
+class PostResource < JSONAPI::Serializable::Model
   type 'posts'
 
-  id
-
   attribute :title
 
   attribute :date do
     @model.created_at
   end
 
-  relationship :author, UserResource do
+  has_one :author, UserResource do
     link(:self) do
       href @url_helper.link_for_rel('posts', @model.id, 'author')
       meta link_meta: 'some meta'
@@ -68,15 +80,16 @@ class PostResource < JSONAPI::Serializable::Resource
   end
 end
 ```
+
 Then, build your resources from your models and render them:
 ```ruby
 # post = some post model
 # UrlHelper is some helper class
 resource = PostResource.new(model: post, url_helper: UrlHelper)
-document = JSONAPI.render(resource)
+document = JSONAPI.render(data: resource)
 ```
 
-### For general resources
+### Example for General Resources
 
 In case your resource is not a simple representation of one of your models,
 the more general `JSONAPI::Serializable::Resource` class can be used.
@@ -129,9 +142,232 @@ Finally, build your resources from your models and render them:
 # post = some post model
 # UrlHelper is some helper class
 resource = PostResource.new(post: post, url_helper: UrlHelper)
-document = JSONAPI.render(resource)
+document = JSONAPI.render(data: resource)
 ```
 
+## Documentation
+
+### `JSONAPI::Serializable::Resource` DSL
+
++ `#initialize(hash)`
+
+All the values of the hash are made available during serialization as instance
+variables within all DSLs.
+
+Example:
+```ruby
+SerializablePost.new(post: post, url_helper: url_helper)
+# => You can then use @post and @url_helper from within the DSL.
+```
+
++ `::type(value = nil, &block)`
+
+Define the type of the resource, either statically, or dynamically as the
+return value of the block.
+
++ `::id(&block)`
+
+Define the id of the resource.
+
+Example:
+```ruby
+id { @post.id }
+```
+
++ `::attribute(key, &block)`
+
+Define an attribute of the resource.
+
+Example:
+```ruby
+attribute(:title) { @post.title }
+```
+
++ `::relationship(key, &block)`
+
+Define a relationship of the resource. The block can contain any instruction of
+the [`JSONAPI::Serializable::Relationship` DSL](#jsonapiserializablerelationship-dsl).
+
+Example:
+```ruby
+relationship :comments do
+  data do
+    @post.comments.map do |c|
+      SerializableComment.new(comment: c, url_helper: @url_helper)
+    end
+  end
+  link :self do
+    @url_helper.link_for_post_comments(post_id: @post.id)
+  end
+  meta do
+    { count: @post.comments.count }
+  end
+end
+```
+
++ `::link(key, &block)`
+
+Define a resource-level link. The block can either return a string or contain
+any instruction of the [`JSONAPI::Serializable::Link` DSL](#jsonapiserializablelink-dsl).
+
+Example:
+```ruby
+link :self do
+  "http://api.example.com/posts/#{@post.id}"
+end
+```
+
++ `::meta(value = nil, &block)`
+
+Define a resource-level meta member. The value can either be provided
+statically, or dynamically as the return value of a block.
+
+Examples:
+```ruby
+meta(experimental: true)
+```
+```ruby
+meta do
+  { remaining_time: @post.remaining_time }
+end
+```
+
+### `JSONAPI::Serializable::Model` DSL
+
+This class is a subclass of `JSONAPI::Serializable::Resource` with a more
+convenient DSL tailored for resources that are direct representation of some
+business models.
+
++ `#initialize(hash)`
+
+See `JSONAPI::Serializable::Resource` DSL.
+
+The model is expected to be provided in the hash with the key `:model`.
+
++ `::type(value = nil, &block)`
+
+See `JSONAPI::Serializable::Resource` DSL.
+
++ `::id(&block)`
+
+See `JSONAPI::Serializable::Resource` DSL.
+
+Defaults to:
+```ruby
+id { @model.id }
+```
+
++ `::attribute(key, &block)`
+
+See `JSONAPI::Serializable::Resource` DSL.
+
+Defaults to the following when no block is provided:
+```ruby
+attribute key do
+  @model.public_send(key)
+end
+```
+
++ `::has_one(key, resource_klass = nil, &block)`
+
+Define a `has_one` relationship on the resource.
+
+The serializable class for the related resource can be explicitly stated as the
+second parameter, but when omitted it will be infered from the related
+resource's class name.
+
+When no block is provided, the value of the relationship defaults to
+`resource_klass.new(model: @model.public_send(key))`.
+
++ `::has_many(key, resource_klass = nil, &block)`
+
+Define a `has_many` relationship on the resource.
+
+The serializable class for the related resources can be explicitly stated as the
+second parameter, but when omitted it will be infered from the related
+resources' class names.
+
+When no block is provided, the value of the relationship defaults to:
+```ruby
+@model.public_send(key).map do |r|
+  resource_klass.new(model: r)
+end
+```
+
++ `::relationship(key, &block)`
+
+See `JSONAPI::Serializable::Resource` DSL.
+
++ `::link(key, &block)`
+
+See `JSONAPI::Serializable::Resource` DSL.
+
++ `::meta(value = nil, &block)`
+
+See `JSONAPI::Serializable::Resource` DSL.
+
+### `JSONAPI::Serializable::Relationship` DSL
+
++ `::data(resource_class = nil, &block)`
+
+NOTE: This section is outdated. It is still valid, but the data method is now
+much more flexible.
+
+Defines the related serializable resources for the relationship.
+
+Example:
+```ruby
+data do
+  if @post.author.nil?
+    nil
+  else
+    SerializableUser.new(user: @post.author)
+  end
+end
+```
+
++ `::link(key, &block)`
+
+Define a relationship-level link.
+
+See `JSONAPI::Serializable::Resource` DSL.
+
++ `::meta(value = nil, &block)`
+
+Define some relationship-level meta member.
+
+See `JSONAPI::Serializable::Resource` DSL.
+
+### `JSONAPI::Serializable::Link` DSL
+
++ `::href(value = nil, &block)`
+
+Define the href member for the link, either directly, or dynamically as the
+return value of a block.
+
++ `::meta(value = nil, &block)`
+
+Define the meta member for the link, either directly, or dynamically as the
+return value of a block.
+
+### `JSONAPI::Serializable::Error` DSL
+
++ `::id(value = nil, &block)`
+
++ `::status(value = nil, &block)`
+
++ `::code(value = nil, &block)`
+
++ `::title(value = nil, &block)`
+
++ `::detail(value = nil, &block)`
+
++ `::meta(value = nil, &block)`
+
++ `::link(key, &block)`
+
++ `::source(&block)`
+
 ## License
 
 jsonapi-serializable is released under the [MIT License](http://www.opensource.org/licenses/MIT).

data/lib/jsonapi/serializable.rb

@@ -1,3 +1,4 @@
 require 'jsonapi/serializable/error'
 require 'jsonapi/serializable/model'
 require 'jsonapi/serializable/resource'
+require 'jsonapi/serializable/renderer'

data/lib/jsonapi/serializable/model.rb

@@ -6,39 +6,7 @@ module JSONAPI
     class Model < Resource
       include ModelDSL
 
-      class << self
-        attr_accessor :api_version_val
-      end
-
-      def self.inherited(klass)
-        super
-        klass.api_version_val = api_version_val
-      end
-
       id { @model.public_send(:id).to_s }
-
-      def resource_klass_for(model_klass)
-        names = model_klass.name.split('::'.freeze)
-        model_klass_name = names.pop
-        namespace = names.join('::'.freeze)
-        version = self.class.api_version_val
-
-        klass_name = [namespace, version, "Serializable#{model_klass_name}"]
-                     .reject(&:nil?)
-                     .reject(&:empty?)
-                     .join('::'.freeze)
-
-        Object.const_get(klass_name)
-      end
-
-      def nil?
-        @model.nil?
-      end
-
-      def as_jsonapi(params = {})
-        return nil if nil?
-        super(params)
-      end
     end
   end
 end

data/lib/jsonapi/serializable/model_dsl.rb

@@ -6,48 +6,21 @@ module JSONAPI
       end
 
       module ClassMethods
-        def api_version(value)
-          self.api_version_val = value
-        end
-
-        def type(value = nil)
-          value ||= name
-          super(value)
-        end
-
         def attribute(attr, &block)
           block ||= proc { @model.public_send(attr) }
           super(attr, &block)
         end
 
-        def has_many(rel, resource_klass = nil, &block)
-          rel_block = proc do
-            if resource_klass
-              data do
-                @model.public_send(rel).map do |related|
-                  resource_klass ||= resource_klass_for(related.class)
-                  resource_klass.new(model: related)
-                end
-              end
-            end
-            instance_eval(&block) unless block.nil?
-          end
-          relationship(rel, &rel_block)
-        end
-
-        def has_one(rel, resource_klass = nil, &block)
+        def relationship(rel, resource_class = nil, &block)
           rel_block = proc do
-            if resource_klass
-              data do
-                related = @model.public_send(rel)
-                resource_klass ||= resource_klass_for(related.class)
-                resource_klass.new(model: related)
-              end
-            end
+            data(resource_class) { @model.public_send(rel) }
             instance_eval(&block) unless block.nil?
           end
-          relationship(rel, &rel_block)
+          super(rel, &rel_block)
         end
+        alias has_many   relationship
+        alias has_one    relationship
+        alias belongs_to relationship
       end
     end
   end

data/lib/jsonapi/serializable/relationship.rb

@@ -18,24 +18,19 @@ module JSONAPI
         hash[:links] = @_links if @_links.any?
         hash[:meta] = @_meta unless @_meta.nil?
         return hash unless included || (!@_links.any? && @_meta.nil?)
-        hash[:data] = eval_linkage_data
+        hash[:data] = linkage_data
 
         hash
       end
 
       private
 
-      def eval_linkage_data
-        @_linkage_data ||=
-          if @_linkage_data_block
-            @_linkage_data_block.call
-          elsif data.respond_to?(:each)
-            data.map { |res| { type: res.jsonapi_type, id: res.jsonapi_id } }
-          elsif data.nil?
-            nil
-          else
-            { type: data.jsonapi_type, id: data.jsonapi_id }
-          end
+      def linkage_data
+        linkage_data = Array(data).map do |res|
+          { type: res.jsonapi_type, id: res.jsonapi_id }
+        end
+
+        data.respond_to?(:each) ? linkage_data : linkage_data.first
       end
     end
   end

data/lib/jsonapi/serializable/relationship_dsl.rb

@@ -1,40 +1,55 @@
+require 'jsonapi/serializable/resource_builder'
+
 module JSONAPI
   module Serializable
     module RelationshipDSL
-      # Declare/access the data for this relationship.
-      #
-      # @yieldreturn [JSONAPI::Serializable::Resource,
-      #               Array<JSONAPI::Serializable::Resource>,
-      #               nil] The data for this relationship.
+      # Declare the data for this relationship.
+      # @param [String,Constant,Hash{Symbol=>String,Constant}] resource_class
+      # @yieldreturn The data for this relationship.
+      #   If it is nil, an object implementing the Serializable::Resource
+      #   interface, an empty array, or an array of objects implementing the
+      #   Serializable::Resource interface, then it is used as is.
+      #   Otherwise an appropriate Serializable::Model subclass is inferred
+      #   from the object(s)' namespace/class, the resource_class parameter if
+      #   provided, and the @_resource_inferer.
       #
       # @example
-      #   data :posts do
+      #   data do
       #     @user.posts.map { |p| PostResource.new(post: p) }
       #   end
       #
       # @example
-      #   data :author do
-      #     @user.author && UserResource.new(user: @user.author)
+      #   data do
+      #     @post.author && UserResource.new(user: @user.author)
       #   end
-      def data(&block)
-        if block.nil?
-          @_data ||= (@_data_block && @_data_block.call)
-        else
-          @_data_block = block
-        end
-      end
-
-      # Declare the linkage data for this relationship. Useful when linkage
-      #   can be computed in a more efficient way than the data itself.
       #
-      # @yieldreturn [Hash] The block to compute linkage data.
+      # @example
+      #   data do
+      #     @user.posts
+      #   end
+      # end
       #
       # @example
-      #   linkage_data do
-      #     { id: @post.author_id.to_s, type: 'users' }
+      #   data SerializablePost do
+      #     @user.posts
       #   end
-      def linkage_data(&block)
-        @_linkage_data_block = block
+      #
+      # @example
+      #   data "SerializableUser" do
+      #     @post.author
+      #   end
+      def data(resource_class = nil)
+        if block_given?
+          # NOTE(beauby): Lazify computation since it is only needed when
+          #   the corresponding relationship is included.
+          @_data_block = proc do
+            _resources_for(yield, resource_class)
+          end
+        else
+          # NOTE(beauby): In the case of a computation heavy relationship with
+          #   nil value, this block might be executed multiple times.
+          @_data ||= @_data_block.call
+        end
       end
 
       # @overload meta(value)
@@ -77,6 +92,15 @@ module JSONAPI
       def link(name, &block)
         @_links[name] = Link.as_jsonapi(@_param_hash, &block)
       end
+
+      private
+
+      # @api private
+      def _resources_for(models, resource_class)
+        resource_class ||= @_resource_inferer
+
+        ResourceBuilder.build(models, @_param_hash, resource_class)
+      end
     end
   end
 end

data/lib/jsonapi/serializable/renderer.rb

@@ -0,0 +1,72 @@
+require 'jsonapi/renderer'
+
+module JSONAPI
+  module Serializable
+    class Renderer
+      def self.render(resources, options)
+        new(resources, options).render
+      end
+
+      def initialize(resources, options)
+        @resources  = resources
+        @options    = options.dup
+        @klass      = @options.delete(:class)
+        @namespace  = @options.delete(:namespace)
+        @inferer    = @options.delete(:inferer)
+        @exposures  = @options.delete(:expose) || {}
+        @exposures[:_resource_inferer] = namespace_inferer || @inferer
+      end
+
+      def render
+        JSONAPI.render(jsonapi_params.merge(data: jsonapi_resources)).to_json
+      end
+
+      private
+
+      def jsonapi_params
+        @options
+      end
+
+      def jsonapi_resources
+        toplevel_inferer = @klass || @inferer
+        JSONAPI::Serializable::ResourceBuilder.build(@resources,
+                                                     @exposures,
+                                                     toplevel_inferer)
+      end
+
+      def namespace_inferer
+        return nil unless @namespace
+        proc do |klass|
+          names = klass.name.split('::')
+          klass = names.pop
+          [@namespace, names, "Serializable#{klass}"].reject(&:nil?).join('::')
+        end
+      end
+    end
+
+    class ErrorRenderer
+      def self.render(errors, options)
+        new(errors, options).render
+      end
+
+      def initialize(errors, options)
+        @errors    = errors
+        @options   = options.dup
+      end
+
+      def render
+        JSONAPI.render(jsonapi_params.merge(errors: jsonapi_errors)).to_json
+      end
+
+      private
+
+      def jsonapi_params
+        @options
+      end
+
+      def jsonapi_errors
+        @errors
+      end
+    end
+  end
+end

data/lib/jsonapi/serializable/resource.rb

@@ -34,19 +34,21 @@ module JSONAPI
       end
 
       def as_jsonapi(params = {})
-        hash = {}
-        hash[:id] = jsonapi_id
-        hash[:type] = jsonapi_type
-        requested_attrs = params[:fields] || self.class.attribute_blocks.keys
-        attr = attributes(requested_attrs)
-        hash[:attributes] = attr if attr.any?
-        requested_rels = params[:fields] || self.class.relationship_blocks.keys
-        rels = relationships(requested_rels, params[:include] || [])
-        hash[:relationships] = rels if rels.any?
-        hash[:links] = links if links.any?
-        hash[:meta] = meta unless meta.nil?
+        return nil if nil?
 
-        hash
+        {}.tap do |hash|
+          hash[:id] = jsonapi_id
+          hash[:type] = jsonapi_type
+          requested_attrs = params[:fields] || self.class.attribute_blocks.keys
+          attrs = attributes(requested_attrs)
+          hash[:attributes] = attrs if attrs.any?
+          requested_rels = params[:fields] ||
+                           self.class.relationship_blocks.keys
+          rels = relationships(requested_rels, params[:include] || [])
+          hash[:relationships] = rels if rels.any?
+          hash[:links] = links if links.any?
+          hash[:meta] = meta unless meta.nil?
+        end
       end
 
       def jsonapi_type

data/lib/jsonapi/serializable/resource_builder.rb

@@ -0,0 +1,72 @@
+module JSONAPI
+  module Serializable
+    class ResourceBuilder
+      DEFAULT_RESOURCE_INFERER = lambda do |model_klass_name|
+        names = model_klass_name.split('::'.freeze)
+        klass_name = names.pop
+        namespace = names.join('::'.freeze)
+
+        klass_name = [namespace, "Serializable#{klass_name}"]
+                     .reject(&:nil?)
+                     .reject(&:empty?)
+                     .join('::'.freeze)
+
+        Object.const_get(klass_name)
+      end
+
+      def self.build(models, expose, klass)
+        return models if models.nil? ||
+                         Array(models).first.respond_to?(:as_jsonapi)
+
+        resources =
+          Array(models).map { |model| new(model, expose, klass).resource }
+
+        models.respond_to?(:each) ? resources : resources.first
+      end
+
+      attr_reader :resource
+
+      def initialize(model, expose, klass)
+        @model    = model
+        @expose   = expose || {}
+        @klass    = klass
+        @resource = serializable_class.new(serializable_params)
+        freeze
+      end
+
+      private
+
+      def serializable_params
+        @expose.merge(model: @model)
+      end
+
+      # rubocop:disable Metrics/MethodLength
+      def serializable_class
+        klass =
+          if @klass.respond_to?(:call)
+            @klass.call(@model.class.name)
+          elsif @klass.is_a?(Hash)
+            @klass[@model.class.name.to_sym]
+          elsif @klass.nil?
+            DEFAULT_RESOURCE_INFERER.call(@model.class.name)
+          else
+            @klass
+          end
+
+        reify_class(klass)
+      end
+      # rubocop:enable Metrics/MethodLength
+
+      def reify_class(klass)
+        if klass.is_a?(Class)
+          klass
+        elsif klass.is_a?(String)
+          Object.const_get(klass)
+        else
+          # TODO(beauby): Raise meaningful exception.
+          raise
+        end
+      end
+    end
+  end
+end

data/lib/jsonapi/serializable/resource_dsl.rb

@@ -97,6 +97,9 @@ module JSONAPI
         def relationship(name, &block)
           relationship_blocks[name] = block
         end
+        alias has_many   relationship
+        alias has_one    relationship
+        alias belongs_to relationship
 
         # Declare a link for this resource. The properties of the link are set
         #   by providing a block in which the DSL methods of

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: jsonapi-serializable
 version: !ruby/object:Gem::Version
-  version: 0.1.1.beta2
+  version: 0.1.1.beta3
 platform: ruby
 authors:
 - Lucas Hosseini
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-10-25 00:00:00.000000000 Z
+date: 2016-11-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: jsonapi-renderer
@@ -16,43 +16,43 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.1.1.beta2
-  type: :development
+        version: 0.1.1.beta3
+  type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.1.1.beta2
+        version: 0.1.1.beta3
 - !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
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.4'
+        version: '3.5'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.4'
-description: DSL for building resource classes to be rendered by jsonapi-renderer.
+        version: '3.5'
+description: Powerful DSL for building resource classes - efficient and flexible rendering.
 email: lucas.hosseini@gmail.com
 executables: []
 extensions: []
@@ -67,13 +67,11 @@ files:
 - lib/jsonapi/serializable/model_dsl.rb
 - lib/jsonapi/serializable/relationship.rb
 - lib/jsonapi/serializable/relationship_dsl.rb
+- lib/jsonapi/serializable/renderer.rb
 - lib/jsonapi/serializable/resource.rb
+- lib/jsonapi/serializable/resource_builder.rb
 - lib/jsonapi/serializable/resource_dsl.rb
-- lib/jsonapi/serializable_error.rb
-- lib/jsonapi/serializable_link.rb
-- lib/jsonapi/serializable_relationship.rb
-- lib/jsonapi/serializable_resource.rb
-homepage: https://github.com/beauby/jsonapi-serializable
+homepage: https://github.com/jsonapi-rb/serializable
 licenses:
 - MIT
 metadata: {}
@@ -96,5 +94,5 @@ rubyforge_project:
 rubygems_version: 2.5.1
 signing_key: 
 specification_version: 4
-summary: Build and render JSON API resources.
+summary: Conveniently serialize JSON API resources.
 test_files: []

data/lib/jsonapi/serializable_error.rb

@@ -1,93 +0,0 @@
-require 'jsonapi/serializable_link'
-
-module JSONAPI
-  class SerializableErrorSource
-    def self.as_jsonapi(params = {})
-      self.class.new(params).as_jsonapi
-    end
-
-    def initialize(params = {})
-      params.each { |k, v| instance_variable_set("@#{k}", v) }
-      @_data = {}
-    end
-
-    def as_jsonapi
-      @_data
-    end
-
-    private
-
-    def method_missing(name, arg)
-      @_data[name] = arg
-    end
-  end
-
-  class SerializableError
-    class << self
-      attr_accessor :id, :id_block, :status, :status_block, :code, :code_block,
-                    :title, :title_block, :detail, :detail_block, :meta,
-                    :meta_block, :source_block, :link_blocks
-
-      [:id, :status, :code, :title, :detail, :meta].each do |key|
-        define_method(key) do |*args, &block|
-          send("@#{key}=", args[0])
-          send("@#{key}_block=", block)
-        end
-      end
-
-      def link(name, &block)
-        link_blocks[name] = block
-      end
-
-      def source(&block)
-        self.source_block = block
-      end
-    end
-
-    self.link_blocks = {}
-
-    def self.inherited(klass)
-      super
-      klass.link_blocks = self.class.link_blocks.dup
-    end
-
-    def initialize(params = {})
-      @_param_hash = params
-      params.each { |k, v| instance_variable_set("@#{k}", v) }
-    end
-
-    def as_jsonapi
-      hash = links.any? ? { links: links } : {}
-      [:id, :status, :code, :title, :detail, :meta, :source]
-        .each_with_object(hash) do |key, h|
-        value = send(key)
-        h[key] = value unless value.nil?
-      end
-    end
-
-    private
-
-    def links
-      @_links ||= self.class.link_blocks.each_with_object({}) do |(k, v), h|
-        h[k] = JSONAPI::SerializableLink.as_jsonapi(@_param_hash, v)
-      end
-    end
-
-    def source
-      @_source ||=
-        JSONAPI::SerializableErrorSource.as_jsonapi(@_param_hash,
-                                                    self.class.source_block)
-    end
-
-    [:id, :status, :code, :title, :detail, :meta].each do |key|
-      define_method(key) do
-        unless instance_variable_defined?("@#{key}")
-          instance_variable_set("@#{key}",
-                                self.class.send(key) ||
-                                instance_eval(self.class.send("#{key}_block")))
-        end
-        instance_variable_get("@#{key}")
-      end
-    end
-  end
-end

data/lib/jsonapi/serializable_link.rb

@@ -1,34 +0,0 @@
-module JSONAPI
-  class SerializableLink
-    def self.as_jsonapi(param_hash = {}, &block)
-      new(param_hash, &block).as_jsonapi
-    end
-
-    def initialize(param_hash = {}, &block)
-      param_hash.each do |k, v|
-        instance_variable_set("@#{k}", v)
-      end
-      str_value = instance_eval(&block)
-      @_href ||= str_value
-    end
-
-    def as_jsonapi
-      @_hash ||=
-        if @_meta.nil?
-          @_href
-        else
-          { href: @_href, meta: @_meta }
-        end
-    end
-
-    private
-
-    def href(value = nil, &block)
-      @_href = block.nil? ? value : instance_eval(&block)
-    end
-
-    def meta(value = nil, &block)
-      @_meta = block.nil? ? value : instance_eval(&block)
-    end
-  end
-end

data/lib/jsonapi/serializable_relationship.rb

@@ -1,56 +0,0 @@
-require 'jsonapi/serializable_link'
-
-module JSONAPI
-  class SerializableRelationship
-    def initialize(param_hash = {}, &block)
-      @_param_hash = param_hash
-      @_param_hash.each { |k, v| instance_variable_set("@#{k}", v) }
-      @_links = {}
-      instance_eval(&block)
-    end
-
-    def data(&block)
-      if block.nil?
-        @_data ||= @_data_block.call
-      else
-        @_data_block = block
-      end
-    end
-
-    def as_jsonapi(included)
-      hash = {}
-      hash[:links] = @_links if @_links.any?
-      hash[:meta] = @_meta unless @_meta.nil?
-      hash[:data] = eval_linkage_data if included
-
-      hash
-    end
-
-    private
-
-    def eval_linkage_data
-      @_linkage_data ||=
-        if @_linkage_data_block
-          @_linkage_data_block.call
-        elsif data.respond_to?(:each)
-          data.map { |res| { type: res.jsonapi_type, id: res.jsonapi_id } }
-        elsif data.nil?
-          nil
-        else
-          { type: data.jsonapi_type, id: data.jsonapi_id }
-        end
-    end
-
-    def linkage_data(&block)
-      @_linkage_data_block = block
-    end
-
-    def meta(value = nil)
-      @_meta = value || yield
-    end
-
-    def link(name, &block)
-      @_links[name] = JSONAPI::SerializableLink.as_jsonapi(@_param_hash, &block)
-    end
-  end
-end

data/lib/jsonapi/serializable_resource.rb

@@ -1,114 +0,0 @@
-require 'jsonapi/serializable_link'
-require 'jsonapi/serializable_relationship'
-
-module JSONAPI
-  class SerializableResource
-    class << self
-      attr_accessor :type_val, :type_block, :id_block, :attribute_blocks,
-                    :relationship_blocks, :link_blocks, :meta_val, :meta_block
-
-      def type(value = nil, &block)
-        self.type_val = value
-        self.type_block = block
-      end
-
-      def id(&block)
-        self.id_block = block
-      end
-
-      def meta(value = nil, &block)
-        self.meta_val = value
-        self.meta_block = block
-      end
-
-      def attribute(name, &block)
-        attribute_blocks[name] = block
-      end
-
-      def relationship(name, &block)
-        relationship_blocks[name] = block
-      end
-
-      def link(name, &block)
-        link_blocks[name] = block
-      end
-    end
-
-    self.attribute_blocks = {}
-    self.relationship_blocks = {}
-    self.link_blocks = {}
-
-    def self.inherited(klass)
-      super
-      klass.attribute_blocks = attribute_blocks.dup
-      klass.relationship_blocks = relationship_blocks.dup
-      klass.link_blocks = link_blocks.dup
-    end
-
-    def initialize(param_hash = {})
-      param_hash.each { |k, v| instance_variable_set("@#{k}", v) }
-      @_id = instance_eval(&self.class.id_block)
-      @_type = self.class.type_val || instance_eval(&self.class.type_block)
-      @_meta = if self.class.meta_val
-                 self.class.meta_val
-               elsif self.class.meta_block
-                 instance_eval(&self.class.meta_block)
-               end
-      @_attributes = {}
-      @_relationships = self.class.relationship_blocks
-                            .each_with_object({}) do |(k, v), h|
-        h[k] = JSONAPI::SerializableRelationship.new(param_hash, &v)
-      end
-      @_links = self.class.link_blocks
-                    .each_with_object({}) do |(k, v), h|
-        h[k] = JSONAPI::SerializableLink.as_jsonapi(param_hash, &v)
-      end
-    end
-
-    def as_jsonapi(params = {})
-      hash = {}
-      hash[:id] = @_id
-      hash[:type] = @_type
-      attr = attributes(params[:fields] || @_attributes.keys)
-      hash[:attributes] = attr if attr.any?
-      rels = relationships(params[:field] || @_relationships.keys,
-                           params[:include] || [])
-      hash[:relationships] = rels if rels.any?
-      hash[:links] = @_links if @_links.any?
-      hash[:meta] = @_meta unless @_meta.nil?
-
-      hash
-    end
-
-    def jsonapi_type
-      @_type
-    end
-
-    def jsonapi_id
-      @_id
-    end
-
-    def jsonapi_related(include)
-      @_relationships
-        .select { |k, _| include.include?(k) }
-        .each_with_object({}) { |(k, v), h| h[k] = Array(v.data) }
-    end
-
-    private
-
-    def attributes(fields)
-      self.class.attribute_blocks
-          .select { |k, _| !@_attributes.key?(k) && fields.include?(k) }
-          .each { |k, v| @_attributes[k] = instance_eval(&v) }
-      @_attributes.select { |k, _| fields.include?(k) }
-    end
-
-    def relationships(fields, include)
-      @_relationships
-        .select { |k, _| fields.include?(k) }
-        .each_with_object({}) do |(k, v), h|
-        h[k] = v.as_jsonapi(include.include?(k))
-      end
-    end
-  end
-end