jsonapi-serializable 0.1.3 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f59f8e3e6a7affd39f462919816e0931c277699e
-  data.tar.gz: 11647e5104f611adafd09c25e3c81d1b3c26d2f4
+  metadata.gz: a2bfb6228e6b03c8bde3724af76fdbcedc097e0e
+  data.tar.gz: 28e75ac8293502f8e2a617c79fff3f803ca172d7
 SHA512:
-  metadata.gz: 104a61271b884fd79e98308850ee6943c14a195171cccfb00f77a4cd3faeeea38eae0665bb11403bec1674ac5c3b9ee8315552d3cbc611c7df5dbfe949ed7dbe
-  data.tar.gz: 9e840331b935f596a62f1b15fca6e66e74810a0db04d0cde0796bf0ef0cdb80ebba5643995de26bb44f68e58e5bf34d627c486583393b5e7dbdd61fd19704815
+  metadata.gz: 909fa65c618b4507da112491cc7b84646c07146dd027c5ba52386509ed9ea090916b413e78940f3fd4dad8cc2c518d56bd727953ad871ef4b404205ba5c9f39d
+  data.tar.gz: 8d924e246526821a8ab66d571054cdbe50b235c3d909e5c4c3ca935d6f57fac9b6221e3dcde1ce81eeebfcd32e99bf40bbc87e980a1113c0811bf7c76a32133a

data/lib/jsonapi/serializable/error.rb

@@ -35,6 +35,12 @@ module JSONAPI
                       :link_blocks
       end
 
+      def self.create(hash)
+        hash.each_with_object(new) do |(k, v), e|
+          e.instance_variable_set("@_#{k}", v)
+        end
+      end
+
       self.link_blocks = {}
 
       def self.inherited(klass)

data/lib/jsonapi/serializable/relationship.rb

@@ -6,9 +6,10 @@ module JSONAPI
     class Relationship
       include DSL
 
-      def initialize(exposures = {}, &block)
+      def initialize(exposures = {}, options = {}, &block)
         exposures.each { |k, v| instance_variable_set("@#{k}", v) }
         @_exposures = exposures
+        @_options   = options
         @_links     = {}
         instance_eval(&block)
       end

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

@@ -5,14 +5,13 @@ module JSONAPI
     class Relationship
       module DSL
         # Declare the related resources for this relationship.
-        # @param [String,Constant,Hash{Symbol=>String,Constant}] resource_class
         # @yieldreturn The related resources 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::Resource subclass is inferred
-        #   from the object(s)' namespace/class, the resource_class parameter if
-        #   provided, and the @_resource_inferrer.
+        #   from the object(s)' namespace/class, the `class` relationship
+        #   option, and the @_resource_builder.
         #
         # @example
         #   data do
@@ -29,21 +28,11 @@ module JSONAPI
         #     @user.posts
         #   end
         # end
-        #
-        # @example
-        #   data SerializablePost do
-        #     @user.posts
-        #   end
-        #
-        # @example
-        #   data "SerializableUser" do
-        #     @post.author
-        #   end
-        def data(resource_class = nil)
+        def data
           # NOTE(beauby): Lazify computation since it is only needed when
           #   the corresponding relationship is included.
           @_resources_block = proc do
-            _resources_for(yield, resource_class)
+            @_resource_builder.build(yield, @_exposures, @_options[:class])
           end
         end
 
@@ -106,15 +95,6 @@ module JSONAPI
         def link(name, &block)
           @_links[name] = Link.as_jsonapi(@_exposures, &block)
         end
-
-        private
-
-        # @api private
-        def _resources_for(objects, resource_class)
-          resource_class ||= @_resource_inferrer
-
-          ResourceBuilder.build(objects, @_exposures, resource_class)
-        end
       end
     end
   end

data/lib/jsonapi/serializable/renderer.rb

@@ -3,77 +3,86 @@ require 'jsonapi/serializable/resource_builder'
 
 module JSONAPI
   module Serializable
-    class Renderer
-      def self.render(objects, options = {})
-        new(objects, options).render
+    class SuccessRenderer
+      def initialize(renderer = JSONAPI::Renderer.new)
+        @renderer = renderer
       end
 
-      def initialize(objects, options)
-        @objects    = objects
-        @options    = options.dup
-        @klass      = @options.delete(:class)
-        @namespace  = @options.delete(:namespace)
-        @inferrer   = @options.delete(:inferrer) || namespace_inferrer
-        @exposures  = @options.delete(:expose) || {}
-        @exposures[:_resource_inferrer] = @inferrer
+      # Serialize resources into a JSON API document.
+      #
+      # @param resources [nil,Object,Array]
+      # @param options [Hash]@see JSONAPI.render
+      # @option class [Class,Symbol,String,Hash{Symbol,String=>Class,Symbol,String}]
+      #   The serializable resource class(es) to use for the primary resources.
+      # @option namespace [String] The namespace in which to look for
+      #   serializable resource classes.
+      # @option inferrer [#call] The callable used for inferring a serializable
+      #   resource class name from a resource class name.
+      # @option expose [Hash] The exposures made available in serializable
+      #   resource class instances as instance variables.
+      # @return [Hash]
+      #
+      # @example
+      #   renderer.render(nil)
+      #   # => { data: nil }
+      #
+      # @example
+      #   renderer.render(user)
+      #   # => {
+      #          data: {
+      #            type: 'users',
+      #            id: 'foo',
+      #            attributes: { ... },
+      #            relationships: { ... }
+      #          }
+      #        }
+      #
+      # @example
+      #   renderer.render([user1, user2])
+      #   # => { data: [{ type: 'users', id: 'foo', ... }, ...] }
+      def render(resources, options = {})
+        options   = options.dup
+        klass     = options.delete(:class)
+        namespace = options.delete(:namespace)
+        inferrer  = options.delete(:inferrer) || namespace_inferrer(namespace)
+        expose    = options.delete(:expose) || {}
+        resource_builder = JSONAPI::Serializable::ResourceBuilder.new(inferrer)
+        exposures = expose.merge(_resource_builder: resource_builder)
 
-        freeze
-      end
+        resources = resource_builder.build(resources, exposures, klass)
 
-      def render
-        JSONAPI.render(jsonapi_params.merge(data: jsonapi_resources)).to_json
+        @renderer.render(options.merge(data: resources))
       end
 
       private
 
       # @api private
-      def jsonapi_params
-        @options
-      end
-
-      # @api private
-      def jsonapi_resources
-        toplevel_inferrer = @klass || @inferrer
-        JSONAPI::Serializable::ResourceBuilder.build(@objects,
-                                                     @exposures,
-                                                     toplevel_inferrer)
-      end
-
-      # @api private
-      def namespace_inferrer
-        return nil unless @namespace
+      def namespace_inferrer(namespace)
         proc do |class_name|
           names = class_name.split('::')
           klass = names.pop
-          [@namespace, *names, "Serializable#{klass}"].reject(&:nil?).join('::')
+          [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
+    class ErrorsRenderer
+      def initialize(renderer = JSONAPI::Renderer.new)
+        @renderer = renderer
       end
 
-      def render
-        JSONAPI.render(jsonapi_params.merge(errors: jsonapi_errors)).to_json
-      end
-
-      private
-
-      # @api private
-      def jsonapi_params
-        @options
-      end
-
-      # @api private
-      def jsonapi_errors
-        @errors
+      # Serialize errors into a JSON API document.
+      #
+      # @param errors [Array]
+      # @param options [Hash] @see JSONAPI.render
+      # @return [Hash]
+      #
+      # @example
+      #   error = JSONAPI::Serializable::Error.create(id: 'foo', title: 'bar')
+      #   renderer.render([error])
+      #   # => { errors: [{ id: 'foo', title: 'bar' }] }
+      def render(errors, options = {})
+        @renderer.render(options.merge(errors: errors))
       end
     end
   end

data/lib/jsonapi/serializable/resource.rb

@@ -1,9 +1,9 @@
-require 'jsonapi/serializable/resource/id'
-require 'jsonapi/serializable/resource/type'
-require 'jsonapi/serializable/resource/meta'
-require 'jsonapi/serializable/resource/links'
-require 'jsonapi/serializable/resource/attributes'
-require 'jsonapi/serializable/resource/relationships'
+require 'jsonapi/serializable/resource_builder'
+
+require 'jsonapi/serializable/resource/dsl'
+
+require 'jsonapi/serializable/link'
+require 'jsonapi/serializable/relationship'
 
 require 'jsonapi/serializable/resource/conditional_fields'
 require 'jsonapi/serializable/resource/key_format'
@@ -11,24 +11,61 @@ require 'jsonapi/serializable/resource/key_format'
 module JSONAPI
   module Serializable
     class Resource
-      prepend Id
-      prepend Type
-      prepend Meta
-      prepend Links
-      prepend Attributes
-      prepend Relationships
+      extend DSL
 
       # Default the value of id.
       id { @object.public_send(:id).to_s }
 
+      # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
       def initialize(exposures = {})
-        exposures.each { |k, v| instance_variable_set("@#{k}", v) }
-        @_exposures = exposures
+        @_exposures = {
+          _resource_builder: JSONAPI::Serializable::ResourceBuilder.new
+        }.merge(exposures)
+        @_exposures.each { |k, v| instance_variable_set("@#{k}", v) }
+
+        @_id = instance_eval(&self.class.id_block).to_s
+        @_type = if (b = self.class.type_block)
+                   instance_eval(&b).to_sym
+                 else
+                   self.class.type_val || :unknown
+                 end
+        @_relationships = self.class.relationship_blocks
+                              .each_with_object({}) do |(k, v), h|
+          opts = self.class.relationship_options[k] || {}
+          h[k] = Relationship.new(@_exposures, opts, &v)
+        end
+        @_meta = if (b = self.class.meta_block)
+                   instance_eval(&b)
+                 else
+                   self.class.meta_val
+                 end
+
+        freeze
       end
+      # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
 
-      def as_jsonapi(*)
-        {}
+      # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+      def as_jsonapi(fields: nil, include: [])
+        attrs = requested_attributes(fields).each_with_object({}) do |(k, v), h|
+          h[k] = instance_eval(&v)
+        end
+        rels = requested_relationships(fields)
+               .each_with_object({}) do |(k, v), h|
+          h[k] = v.as_jsonapi(include.include?(k))
+        end
+        links = link_blocks.each_with_object({}) do |(k, v), h|
+          h[k] = Link.as_jsonapi(@_exposures, &v)
+        end
+        {}.tap do |hash|
+          hash[:id]   = @_id
+          hash[:type] = @_type
+          hash[:attributes]    = attrs if attrs.any?
+          hash[:relationships] = rels  if rels.any?
+          hash[:links] = links if links.any?
+          hash[:meta]  = @_meta  unless @_meta.nil?
+        end
       end
+      # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
 
       def jsonapi_type
         @_type
@@ -43,6 +80,24 @@ module JSONAPI
           .select { |k, _| include.include?(k) }
           .each_with_object({}) { |(k, v), h| h[k] = v.related_resources }
       end
+
+      private
+
+      # @api private
+      def requested_attributes(fields)
+        self.class.attribute_blocks
+            .select { |k, _| fields.nil? || fields.include?(k) }
+      end
+
+      # @api private
+      def requested_relationships(fields)
+        @_relationships.select { |k, _| fields.nil? || fields.include?(k) }
+      end
+
+      # @api private
+      def link_blocks
+        self.class.link_blocks
+      end
     end
   end
 end

data/lib/jsonapi/serializable/resource/conditional_fields.rb

@@ -5,7 +5,7 @@ module JSONAPI
       #
       # @usage
       #   class SerializableUser < JSONAPI::Serializable::Resource
-      #     prepend JSONAPI::Serializable::Resource::ConditionalFields
+      #     extend JSONAPI::Serializable::Resource::ConditionalFields
       #
       #     attribute :email, if: -> { @current_user.admin? }
       #     has_many :friends, unless: -> { @object.private_profile? }
@@ -13,67 +13,107 @@ module JSONAPI
       #
       module ConditionalFields
         def self.prepended(klass)
+          warn <<-EOT
+  DERPRECATION WARNING (called from #{caller_locations(1...2).first}):
+  Prepending `#{name}' is deprecated and will be removed in future releases. Use `Object#extend' instead.
+  EOT
+
+          klass.extend self
+        end
+
+        def self.extended(klass)
           klass.class_eval do
-            extend DSL
+            include InstanceMethods
             class << self
-              attr_accessor :condition_blocks
+              attr_accessor :field_condition_blocks
+              attr_accessor :link_condition_blocks
             end
-            self.condition_blocks ||= {}
+            self.field_condition_blocks ||= {}
+            self.link_condition_blocks ||= {}
           end
         end
 
-        # DSL extensions for conditional fields.
-        module DSL
-          def inherited(klass)
-            super
-            klass.condition_blocks = condition_blocks.dup
-          end
+        def inherited(klass)
+          super
+          klass.field_condition_blocks = field_condition_blocks.dup
+          klass.link_condition_blocks = link_condition_blocks.dup
+        end
 
-          # Handle the `if` and `unless` options for attributes.
-          #
-          # @example
-          #   attribute :email, if: -> { @current_user.admin? }
-          #
-          def attribute(name, options = {}, &block)
-            super
-            _register_condition(name, options)
-          end
+        # Handle the `if` and `unless` options for attributes.
+        #
+        # @example
+        #   attribute :email, if: -> { @current_user.admin? }
+        #
+        def attribute(name, options = {}, &block)
+          super
+          _register_condition(field_condition_blocks, name, options)
+        end
 
-          # Handle the `if` and `unless` options for relationships (has_one,
-          #   belongs_to, has_many).
-          #
-          # @example
-          #   has_many :friends, unless: -> { @object.private_profile? }
-          #
-          def relationship(name, options = {}, &block)
-            super
-            _register_condition(name, options)
-          end
+        # Handle the `if` and `unless` options for relationships (has_one,
+        #   belongs_to, has_many).
+        #
+        # @example
+        #   has_many :friends, unless: -> { @object.private_profile? }
+        #
+        def relationship(name, options = {}, &block)
+          super
+          _register_condition(field_condition_blocks, name, options)
+        end
 
-          # @api private
-          def _register_condition(name, options)
-            condition_blocks[name.to_sym] =
-              if options.key?(:if)
-                options[:if]
-              elsif options.key?(:unless)
-                proc { !instance_exec(&options[:unless]) }
-              end
-          end
+        # Handle the `if` and `unless` options for links.
+        #
+        # @example
+        #
+        #   link :self, if: -> { @object.render_self_link? } do
+        #     "..."
+        #   end
+        def link(name, options = {}, &block)
+          super(name, &block)
+          _register_condition(link_condition_blocks, name, options)
+        end
+
+        # NOTE(beauby): Re-aliasing those is necessary for the
+        #   overridden `#relationship` method to be called.
+        alias has_many   relationship
+        alias has_one    relationship
+        alias belongs_to relationship
+
+        # @api private
+        def _register_condition(condition_blocks, name, options)
+          condition_blocks[name.to_sym] =
+            if options.key?(:if)
+              options[:if]
+            elsif options.key?(:unless)
+              proc { !instance_exec(&options[:unless]) }
+            end
         end
+      end
 
+      module InstanceMethods
         # @api private
         def requested_attributes(fields)
-          super.select { |k, _| _conditionally_included?(k) }
+          super.select do |k, _|
+            _conditionally_included?(self.class.field_condition_blocks, k)
+          end
         end
 
         # @api private
         def requested_relationships(fields)
-          super.select { |k, _| _conditionally_included?(k) }
+          super.select do |k, _|
+            _conditionally_included?(self.class.field_condition_blocks, k)
+          end
+        end
+
+        # @api private
+        def link_blocks
+          super.select do |k, _|
+            _conditionally_included?(self.class.link_condition_blocks, k)
+          end
         end
 
         # @api private
-        def _conditionally_included?(field)
-          condition = self.class.condition_blocks[field]
+        def _conditionally_included?(condition_blocks, field)
+          condition = condition_blocks[field]
           condition.nil? || instance_exec(&condition)
         end
       end