shamu 0.0.3 → 0.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 027f0ea99b484c02d9986999b39f3025dee4b4a3
-  data.tar.gz: 0eb00f3878a9718c979e511e8930cf81d8d708e8
+  metadata.gz: 7dbbdb9cc8883493b91766988eafe575fdc6d7b4
+  data.tar.gz: c4c2e75d33b28dd7759d656d60c5b1dd444a3dc7
 SHA512:
-  metadata.gz: 75946cc4efced52d7a3cf58bb673c75cdd2d9a7aee479b91f3fff4c96d485b74319f07c22345c616075a598948ee861eecd816046aefd37f9761321981c3d11e
-  data.tar.gz: 63784d0e8b20db671ba1563c19146ecea4e2fa3728098fc1a79db42e8ef2ebf57a7e68716c9aa349676dff841b6c92f4c73fc81f660df3bbe3fca4d1a8b953ba
+  metadata.gz: ff33cde446d56d6a4d0930f0cd74d00b9a893af315bf2dcdcfb70f0289f33d53cdcfa93c229df4672c54947d1ec409cd8fb195913607be34b8432d972fc49b8d
+  data.tar.gz: e47d92497b0485d0cb356550d932aacce2f2a8a47177b2f3e51f7ff960ed2d990301f00a176751ca4b4ff9861edbcaa784de6da7bacad103b4f92a1be907de12

data/lib/shamu/attributes.rb

@@ -135,6 +135,11 @@ module Shamu
         @attributes ||= {}
       end
 
+      # @return [Hash] of all association {.attributes} defined on the class.
+      def associations
+        attributes.select { |_, v| v[:association] }
+      end
+
       def inherited( subclass )
         # Clone the base class's attributes into the subclass
         subclass.instance_variable_set :@attributes, attributes.dup
@@ -143,8 +148,8 @@ module Shamu
 
       # Define a new attribute for the class.
       #
-      # @overload attribute(name, on:, default:, build: )
-      # @overload attribute(name, build, on:, default:)
+      # @overload attribute(name, on:, default:, build:, &block )
+      # @overload attribute(name, build, on:, default:, &block)
       #
       # @param [Symbol] name of the attribute.
       # @param [Symbol] as an alias of the attribute.
@@ -174,10 +179,21 @@ module Shamu
         private :"fetch_#{ name }"
         private :"assign_#{ name }"
 
-
         self
       end
 
+      # Define an {.attribute} that defines an association to another resource
+      # that also has it's own attributes.
+      #
+      # @param (see .attribute)
+      # @yieldreturn (see .attribute)
+      # @return [self]
+      def association( name, *args, **options, &block )
+        options[:association] = true
+
+        attribute( name, *args, **options, &block )
+      end
+
       private
 
         # @return [Array<Symbol>] keys used by the {.attribute} method options

data/lib/shamu/json_api/base_builder.rb

@@ -4,24 +4,30 @@ module Shamu
     # Used by a {Serilaizer} to write fields and relationships
     class BaseBuilder
 
+      # ============================================================================
+      # @!group Attributes
+      #
+
+      # @!attribute
+      # @return [Context] the JSON serialization context.
+        attr_reader :context
+
+      #
+      # @!endgroup Attributes
+
+
       # @param [Context] context the current serialization context.
       def initialize( context )
         @context = context
         @output = {}
       end
 
-      # @overload identifier( type, id )
-      #   @param [String] type of the resource.
-      #   @param [Object] id of the resource.
-      # @overload identifier( resource )
-      #   @param [#json_api_type,#id] resource an object that responds to `json_api_type` and `id`
-      #
       # Write a resource linkage info.
       #
+      # @param [String] type of the resource.
+      # @param [Object] id of the resource.
       # @return [void]
       def identifier( type, id = nil )
-        type, id = type.json_api_type, type.id if type.respond_to? :json_api_type
-
         output[:type] = type.to_s
         output[:id]   = id.to_s
       end
@@ -59,7 +65,6 @@ module Shamu
 
       private
 
-        attr_reader :context
         attr_reader :output
 
     end

data/lib/shamu/json_api/context.rb

@@ -2,28 +2,53 @@ module Shamu
   module JsonApi
     class Context
 
-      def initialize( fields: nil )
+      # @param [Hash<Symbol,Array>] fields explicitly declare the attributes and
+      #     resources that should be included in the response. The hash consists
+      #     of a keys of the resource types and values as an array of fields to
+      #     be included.
+      #
+      #     A String value will be split on `,` to allow for easy parsing of
+      #     HTTP query parameters.
+      #
+      # @param [Array<String>] namespaces to look for resource {Presenter
+      #     presenters}. See {#find_presenter}.
+      #
+      # @param [Hash<Class,Class>] presenters a hash that maps resource classes
+      #     to the presenter class to use when building responses. See
+      #     {#find_presenter}.
+      def initialize( fields: nil, namespaces: [], presenters: {} )
         @included_resources = {}
         @all_resources = Set.new
         @fields = parse_fields( fields )
+        @namespaces = Array( namespaces )
+        @presenters = presenters || {}
       end
 
       # Add an included resource for a compound response.
       #
+      # If no `presenter` and no block are provided a default presenter will be
+      # obtained by calling {#find_presenter}.
+      #
       # @param [Object] resource to be serialized.
-      # @param [Serializer] the serializer to use to serialize the object. If
-      #     not provided a default {Serializer} will be chosen.
+      # @param [Presenter] presenter to use to serialize the object. If
+      #     not provided a default {Presenter} will be chosen.
       # @return [resource]
       # @yield (builder)
       # @yieldparam [ResourceBuilder] builder to write embedded resource to.
-      def include_resource( resource, serializer = nil, &block )
+      def include_resource( resource, presenter = nil, &block )
         return if all_resources.include?( resource )
 
         all_resources << resource
-        included_resources[resource] ||= { serializer: serializer, block: block }
+        included_resources[resource] ||= begin
+          presenter ||= find_presenter( resource ) unless block
+          { presenter: presenter, block: block }
+        end
       end
 
       # Collects all the currently included resources and resets the queue.
+      #
+      # @return [Array<Object,Hash>] returns the the resource and presentation
+      #     options from each resource buffered with {#include_resource}.
       def collect_included_resources
         included = included_resources.dup
         @included_resources = {}
@@ -39,18 +64,52 @@ module Shamu
       #
       # @param [Symbol] type the resource type in question.
       # @param [Symbol] name of the field on the resouce in question.
-      # @return [Boolean] true if the
-      def include_field?( type, name )
-        return true unless type_fields = fields[ type ]
+      # @param [Boolean] default true if the field should be included by default
+      #     when no explicit fields have been selected.
+      # @return [Boolean] true if the field should be included.
+      def include_field?( type, name, default = true )
+        return default unless type_fields = fields[ type ]
 
         type_fields.include?( name )
       end
 
+      # Find a {Presenter} that can write the resource to a {ResourceBuilder}.
+      #
+      # - First looks for any explicit presenter given to the constructor that
+      #   maps the resource's class to a specific presenter.
+      # - Next, looks through each of the namespaces given to the constructor.
+      #   For each namespace, looks for a `Namespace::#{ resource.class.name
+      #   }Presenter`. Will also check `resource.class.model_name.name` if
+      #   available.
+      # - Fails with a {NoPresenter} error if a presenter cannot be found.
+      #
+      # @param [Object] resource to present.
+      # @return [Presenter]
+      # @raise [NoPresenter] if a presenter cannot be found.
+      def find_presenter( resource )
+        presenter   = presenters[ resource.class ]
+        presenter ||= find_namespace_presenter( resource )
+
+        fail NoPresenter.new( resource, namespaces ) unless presenter
+
+        presenter.is_a?( Class ) ? presenter.new : presenter
+      end
+
+
+      # @return [Hash] of request param options to be output in the response meta.
+      def params_meta
+        return unless fields.any?
+
+        { fields: fields }
+      end
+
       private
 
         attr_reader :all_resources
         attr_reader :included_resources
         attr_reader :fields
+        attr_reader :namespaces
+        attr_reader :presenters
 
         def parse_fields( raw )
           return {} unless raw
@@ -64,6 +123,28 @@ module Shamu
             end
           end
         end
+
+        def find_namespace_presenter( resource )
+          presenter   = find_namespace_presenter_for( resource.class.name.demodulize )
+          presenter ||= find_namespace_presenter_for( resource.model_name.element.camelize )       if resource.respond_to?( :model_name )        # rubocop:disable Metrics/LineLength
+          presenter ||= find_namespace_presenter_for( resource.class.model_name.element.camelize ) if resource.class.respond_to?( :model_name )  # rubocop:disable Metrics/LineLength
+          presenter
+        end
+
+        def find_namespace_presenter_for( name )
+          name = "#{ name }Presenter".to_sym
+
+          namespaces.each do |namespace|
+            begin
+              scope = namespace.constantize
+              return scope.const_get( name, false ) if scope.const_defined?( name, false )
+            rescue NameError # rubocop:disable Lint/HandleExceptions
+            end
+          end
+
+          nil
+        end
+
     end
   end
 end

data/lib/shamu/json_api/error.rb

@@ -25,5 +25,11 @@ module Shamu
         super
       end
     end
+
+    class NoPresenter < Error
+      def initialize( resource, namespaces )
+        super translate( :no_presenter, class: resource.class, namespaces: namespaces )
+      end
+    end
   end
 end

data/lib/shamu/json_api/error_builder.rb

@@ -1,3 +1,5 @@
+require "rack"
+
 module Shamu
   module JsonApi
 
@@ -17,7 +19,9 @@ module Shamu
       # @param [Integer] http_status code.
       # @param [String,Symbol] code application specific code for the error.
       # @param [String] human friendly title for the error.
-      def summary( http_status, code, title = nil )
+      def summary( http_status, code = nil, title = nil )
+        code ||= ::Rack::Util::HTTP_STATUS_CODES[ code ].to_s.underscore
+
         output[:status] = http_status.to_s
         output[:code]   = code.to_s
         output[:title]  = title || code.to_s.titleize
@@ -27,7 +31,7 @@ module Shamu
       # @param [Exception] exception
       # @param [Integer] http_status code. Default 400.
       def exception( exception, http_status = nil )
-        http_status ||= 400
+        http_status ||= 500
 
         name = exception.class.name.demodulize.gsub( /Error$/, "" )
         summary http_status, name.underscore, name.titleize

data/lib/shamu/json_api/presenter.rb

@@ -0,0 +1,18 @@
+module Shamu
+  module JsonApi
+
+    # Present an object to a JSON API {ResourceBuilder builder}.
+    class Presenter
+
+      # Serialize the `resource` to the `builder`.
+      #
+      # @param [Object] resource to present.
+      # @param [ResourceBuilder] builder to write to.
+      # @return [void]
+      def present( resource, builder )
+        fail NotImplementedError
+      end
+
+    end
+  end
+end

data/lib/shamu/json_api/response.rb

@@ -6,30 +6,32 @@ module Shamu
 
       # Output a single resource as the response data.
       # @param [Object] resource to write.
-      # @param [Serializer] serializer used to write the resource state.
+      # @param [Presenter] presenter used to write the resource state.
       # @yield (builder)
       # @yieldparam [ResourceBuilder] builder used write the resources fields
       #     and meta.
       #
-      # @return [void]
-      def resource( resource, serializer = nil, &block )
-        output[:data] = build_resource( resource, serializer, &block )
+      # @return [self]
+      def resource( resource, presenter = nil, &block )
+        output[:data] = build_resource( resource, presenter, &block )
+        self
       end
 
-      # Output a single resource as the response data.
+      # Output a multiple resources as the response data.
       #
       # @param [Enumerable<Object>] resources to write.
-      # @param [Serializer] serializer used to write the resource state.
+      # @param [Presenter] presenter used to write the resource state.
       # @yield (builder, resource)
       # @yieldparam [ResourceBuilder] builder used write the resources fields
       #     and meta.
       # @yieldparam [Object] resource being written.
-      # @return [void]
-      def resources( collection, serializer = nil, &block )
+      # @return [self]
+      def collection( collection, presenter = nil, &block )
         output[:data] =
           collection.map do |resource|
-            build_resource resource, serializer, &block
+            build_resource resource, presenter, &block
           end
+        self
       end
 
       # @overload error( exception, http_status = nil )
@@ -38,18 +40,23 @@ module Shamu
       #   @yield (builder)
       #   @yieldparam [ErrorBuilder] builder used to describe the error.
       #
-      # @return [void]
+      # @return [self]
       def error( exception = nil, http_status = nil, &block )
         builder = ErrorBuilder.new
 
         if block_given?
           yield builder
-        else
+        elsif exception.is_a?( Exception )
           builder.exception( exception, http_status )
+        else
+          http_status ||= 500
+          builder.summary http_status, http_status.to_s, exception
         end
 
         errors = ( output[:errors] ||= [] )
         errors << builder.compile
+
+        self
       end
 
       # (see BaseBuilder#compile)
@@ -57,11 +64,15 @@ module Shamu
         @compiled ||= begin
           compiled = output.dup
           compiled[:jsonapi] = { version: "1.0" }
+          if params_meta = context.params_meta
+            compiled[:meta] ||= {}
+            compiled[:meta].reverse_merge!( params_meta )
+          end
 
           while context.included_resources?
             included = ( compiled[ :included ] ||= [] )
             context.collect_included_resources.each do |resource, options|
-              included << build_resource( resource, options[:serializer], &options[:block] )
+              included << build_resource( resource, options[:presenter], &options[:block] )
             end
           end
 
@@ -69,24 +80,32 @@ module Shamu
         end
       end
 
-      def to_json
+      # @return [Hash] the compiled resources.
+      def as_json( * )
+        compile.as_json
+      end
+
+      # @return [String]
+      def to_json( * )
         compile.to_json
       end
 
+      # @return [String]
       def to_s
-        compile.to_s
+        to_json
       end
 
-      private :identifier
+      # Responses don't have identifiers
+      undef :identifier
 
       private
 
-        def build_resource( resource, serializer, &block )
-          fail "A block is required if no serializer is given" if !serializer && !block_given?
+        def build_resource( resource, presenter, &block )
+          presenter = context.find_presenter( resource ) if !presenter && !block_given?
 
           builder = ResourceBuilder.new( context )
-          if serializer
-            serializer.serialize( builder )
+          if presenter
+            presenter.present( resource, builder )
           else
             yield builder
           end

data/lib/shamu/json_api.rb

@@ -5,8 +5,7 @@ module Shamu
     require "shamu/json_api/relationship_builder"
     require "shamu/json_api/resource_builder"
     require "shamu/json_api/response"
-    require "shamu/json_api/serializer"
-    require "shamu/json_api/support"
+    require "shamu/json_api/presenter"
     require "shamu/json_api/error"
     require "shamu/json_api/error_builder"
   end

data/lib/shamu/locale/en.yml

@@ -28,5 +28,6 @@ en:
 
     json_api:
       errors:
-        incomplete_resource: "`identifier` was not called to define the type and id of the resource"
-        identifier_resource: "`identifier` must be called before defining any fields"
+        incomplete_resource: "`identifier` was not called to define the type and id of the resource."
+        identifier_resource: "`identifier` must be called before defining any fields."
+        no_presenter: No presenter available for %{class} objects. Looked in %{namespaces}.

data/lib/shamu/rails/json_api.rb

@@ -0,0 +1,217 @@
+require "rack"
+
+module Shamu
+  module Rails
+
+    # Add support for writing resources as well-formed JSON API.
+    module JsonApi
+      extend ActiveSupport::Concern
+
+      included do
+        before_action do
+          json_api error: "The 'include' parameter is not supported", status: :bad_request if params[:include]
+        end
+      end
+
+      private
+
+        # @!visibility public
+        #
+        # Writes a single resource as a well-formed JSON API response.
+        #
+        # @param [Object] resource to present as JSON.
+        # @param [JsonApi::Presenter] presenter to use when building the
+        #     response. If not given, attempts to find a presenter. See
+        #     {#json_context}
+        # @param (see #json_context)
+        # @yield (response) write additional top-level links and meta
+        #     information.
+        # @yieldparam [JsonApi::Response] response
+        # @return [JsonApi::Response] the presented json response.
+        def json_resource( resource, presenter = nil, **context, &block )
+          context  = json_context( **context )
+          response = Shamu::JsonApi::Response.new( context )
+          response.resource resource, presenter
+          yield response if block_given?
+          response
+        end
+
+        # @!visibility public
+        #
+        # Writes a single resource as a well-formed JSON API response.
+        #
+        # @param [Enumerabl<Object>] resources to present as a JSON array.
+        # @param [JsonApi::Presenter] presenter to use when building the
+        #     response. If not given, attempts to find a presenter. See
+        #     {#json_context}
+        # @param (see #json_context)
+        # @yield (response) write additional top-level links and meta
+        #     information.
+        # @yieldparam [JsonApi::Response] response
+        # @return [JsonApi::Response] the presented json response.
+        def json_collection( resources, presenter = nil, pagination: :auto, **context, &block )
+          context  = json_context( **context )
+          response = Shamu::JsonApi::Response.new( context )
+          response.collection resources, presenter
+          json_paginate_resources response, resources, pagination
+          yield response if block_given?
+          response
+        end
+
+        # @!visibility public
+        #
+        # Add page-based pagination links for the resources.
+        #
+        # @param [#current_page,#next_page,#previous_page] resources a collection that responds to `#current_page`
+        # @param [JsonApi::BaseBuilder] builder to add links to.
+        # @param [String] param the name of the page parameter to adjust for
+        def json_paginate( resources, builder, param: "page[number]" )
+          page = resources.current_page
+
+          if resources.respond_to?( :next_page ) ? resources.next_page : true
+            builder.link :next, url_for( params.reverse_merge( param => resources.current_page + 1 ) )
+          end
+
+          if resources.respond_to?( :prev_page ) ? resources.prev_page : page > 1
+            builder.link :prev, url_for( params.reverse_merge( param => resources.current_page - 1 ) )
+          end
+        end
+
+        # @!visiblity public
+        #
+        # Write an error response. See {Shamu::JsonApi::Response#error} for details.
+        #
+        # @param (see Shamu::JsonApi::Response#error)
+        # @return [Shamu::JsonApi::Response]
+        # @yield (builder)
+        # @yieldparam [Shamu::JsonApi::ErrorBuilder] builder to customize the
+        #     error response.
+        def json_error( exception = nil, http_status = :auto, **context, &block )
+          context  = json_context( **context )
+          response = Shamu::JsonApi::Response.new( context )
+
+          http_status = json_http_status_code_from_error( exception ) if http_status == :auto
+          http_status = ::Rack::Utils.status_code( http_status )      if http_status
+          response.error( exception, http_status, &block )
+          response
+        end
+
+        # @!visibility public
+        #
+        # Buid a {JsonApi::Context} for the current request and controller.
+        #
+        # @param [Hash<Symbol,Array>] fields to include in the response. If not
+        #     provided looks for a `fields` request argument and parses that.
+        #     See {JsonApi::Context#initialize}.
+        # @param [Array<String>] namespaces to look for {Presenter presenters}.
+        #     If not provided automatically adds the controller name and it's
+        #     namespace.
+        #
+        #     For example in the `Users::AccountController` it will add the
+        #     `Users::Accounts` and `Users` namespaces.
+        #
+        #     See {JsonApi::Context#find_presenter}.
+        # @param [Hash<Class,Class>] presenters a hash that maps resource classes
+        #     to the presenter class to use when building responses. See
+        #     {JsonApi::Context#find_presenter}.
+        def json_context( fields: :not_set, namespaces: :not_set, presenters: :not_set )
+          Shamu::JsonApi::Context.new fields: fields == :not_set ? json_context_fields : fields,
+                                      namespaces: namespaces == :not_set ? json_context_namespaces : namespaces,
+                                      presenters: presenters == :not_set ? json_context_presenters : presenters
+        end
+
+        # rubocop:disable Metrics/PerceivedComplexity
+
+        # @!visibility public
+        #
+        # Render a JSON API response for a resource, collection or error.
+        #
+        # @overload json_api( error:, status: :auto, **context, &block )
+        #   @param [Exception] error an error to report
+        #   @param [Symbol,Integer] status the HTTP status code to return. If
+        #       :auto, attempts to determine the proper response from the
+        #       exception and request type.
+        #   @param (see #json_context)
+        # @overload json_api( resource:, status: :auto, presenter: nil, **context, &block )
+        #   @param [Object] resource  the resource to render.
+        #   @param [Symbol,Integer] status the HTTP status code. If :auto
+        #       attempts to determine the proper response from the request type.
+        #   @param (see #json_resource)
+        #   @param [Shamu::JsonApi::Presenter] presenter to use when serializing
+        #     the resource.
+        # @overload json_api( collection:, status: :ok, presenter: nil, **context, &block )
+        #   @param [Array<Object>] collection to render.
+        #   @param [Symbol,Integer] statis HTTP status code.
+        #   @param (see #json_collection)
+        #   @param [Shamu::JsonApi::Presenter] presenter to use when serializing
+        #     each of the resources.
+        def json_api( error: nil, resource: nil, collection: nil, status: :auto, presenter: nil, pagination: :auto, **context, &block ) # rubocop:disable  Metrics/LineLength
+          options = { layout: nil }
+
+          options[:json] =
+            if error
+              status = json_http_status_code_from_error( error ) if status == :auto
+              json_error( error, status, **context, &block )
+            elsif collection
+              status = :ok if status == :auto
+              json_collection( collection, presenter, pagination: pagination, **context, &block )
+            else
+              status = json_http_status_code_from_request if status == :auto
+              json_resource( resource, presenter, **context, &block )
+            end
+
+          options[:status] = status if status
+          render options.merge( context.except( :fields, :namespaces, :presenters ) )
+        end
+
+        def json_context_fields
+          params[:fields]
+        end
+
+        def json_context_namespaces
+          name = self.class.name.sub /Controller$/, ""
+          namespaces = [ name.pluralize ]
+          loop do
+            name = name.deconstantize
+            break if name.blank?
+
+            namespaces << name
+          end
+
+          namespaces
+        end
+
+        def json_context_presenters
+        end
+
+        def json_paginate_resources( response, resources, pagination )
+          pagination = resources.respond_to?( :current_page ) if pagination == :auto
+          return unless pagination
+
+          json_paginate resources, response
+        end
+
+        def json_http_status_code_from_error( error )
+          case error
+          when ActiveRecord::RecordNotFound then :not_found
+          when ActiveRecord::RecordInvalid  then :unprocessable_entity
+          when /AccessDenied/               then :forbidden
+          else
+            if error.is_a?( Exception )
+              ActionDispatch::ExceptionWrapper.status_code_for_exception( error )
+            else
+              :bad_request
+            end
+          end
+        end
+
+        def json_http_status_code_from_request
+          case request.method
+          when "POST"  then :created
+          when "HEAD"  then :no_content
+          else              :ok
+          end
+        end
+    end
+  end
+end

data/lib/shamu/rails/railtie.rb

@@ -16,6 +16,7 @@ module Shamu
           ::ActionController::Base.send :include, Shamu::Rails::Controller
           ::ActionController::Base.send :include, Shamu::Rails::Entity
           ::ActionController::Base.send :include, Shamu::Rails::Features
+          ::ActionController::Base.send :include, Shamu::Rails::JsonApi
         end
       end
 

data/lib/shamu/rails.rb

@@ -5,6 +5,7 @@ module Shamu
     require "shamu/rails/entity"
     require "shamu/rails/controller"
     require "shamu/rails/features"
+    require "shamu/rails/json_api"
     require "shamu/rails/railtie"
   end
 end

data/lib/shamu/version.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 module Shamu
   # The primary version number
-  VERSION_NUMBER  = "0.0.3".freeze
+  VERSION_NUMBER  = "0.0.4".freeze
 
   # Version suffix such as 'beta' or 'alpha'
   VERSION_SUFFIX  = "".freeze

data/shamu.gemspec

@@ -17,7 +17,7 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
 
-  spec.required_ruby_version = ">= 2.3.0"
+  spec.required_ruby_version = ">= 2.2.0"
 
 
   spec.add_dependency "activemodel", "~> 4.2"

data/spec/lib/shamu/json_api/context_spec.rb

@@ -1,5 +1,14 @@
 require "spec_helper"
 
+module JsonApiContextSpec
+  class SymbolPresenter < Shamu::JsonApi::Presenter
+  end
+
+  class Resource
+    include Shamu::Attributes
+  end
+end
+
 describe Shamu::JsonApi::Context do
   it "parses comma deliminated fields" do
     context = Shamu::JsonApi::Context.new fields: { "user" => "name, email," }
@@ -28,4 +37,30 @@ describe Shamu::JsonApi::Context do
       expect( context.include_field?( :user, :birthdate ) ).not_to be_truthy
     end
   end
+
+  describe "#find_presenter" do
+    it "finds explicitly defined presenter" do
+      klass = Class.new( Shamu::JsonApi::Presenter )
+
+      context = Shamu::JsonApi::Context.new presenters: { String => klass }
+      expect( context.find_presenter( "Ms. Piggy" ) ).to be_a klass
+    end
+
+    it "finds implicitly named presenter in namespaces" do
+      context = Shamu::JsonApi::Context.new namespaces: [ "JsonApiContextSpec" ]
+      expect( context.find_presenter( :symbols ) ).to be_a JsonApiContextSpec::SymbolPresenter
+    end
+
+    it "finds implicitly named model_name presenter in namespaces" do
+      resource = double model_name: ActiveModel::Name.new( Class, nil, "JsonApiContextSpec::Symbol" )
+      context = Shamu::JsonApi::Context.new namespaces: [ "JsonApiContextSpec" ]
+      expect( context.find_presenter( resource ) ).to be_a JsonApiContextSpec::SymbolPresenter
+    end
+
+    it "raises if no presenter can be found" do
+      expect do
+        Shamu::JsonApi::Context.new.find_presenter double
+      end.to raise_error Shamu::JsonApi::NoPresenter
+    end
+  end
 end

data/spec/lib/shamu/json_api/response_spec.rb

@@ -4,19 +4,19 @@ describe Shamu::JsonApi::Response do
   let( :context )  { Shamu::JsonApi::Context.new }
   let( :response ) { Shamu::JsonApi::Response.new context }
 
-  it "uses serializer if given" do
-    serializer = double Shamu::JsonApi::Serializer
-    expect( serializer ).to receive( :serialize ) do |builder|
+  it "uses presenter if given" do
+    presenter = double Shamu::JsonApi::Presenter
+    expect( presenter ).to receive( :present ) do |_, builder|
       builder.identifier :response, 9
-    end
+    end.with( anything, kind_of( Shamu::JsonApi::ResourceBuilder ) )
 
-    response.resource double, serializer
+    response.resource double, presenter
   end
 
-  it "expects a block if no serializer" do
+  it "expects a block if no presenter" do
     expect do
       response.resource double
-    end.to raise_error /block/
+    end.to raise_error Shamu::JsonApi::NoPresenter
   end
 
   it "appends included resources" do

data/spec/lib/shamu/rails/json_api_spec.rb

@@ -0,0 +1,106 @@
+require "rails_helper"
+
+module JsonApiControllerSpec
+
+  class Resource < Shamu::Entities::Entity
+    attribute :id
+    attribute :name
+  end
+
+  class ResourcesController < ActionController::Base
+  end
+
+  module Resources
+    class ResourcePresenter
+      def present( resource, builder )
+        builder.identifier :resource, resource.id
+        builder.attribute name: resource.name
+      end
+    end
+  end
+
+end
+
+describe JsonApiControllerSpec::ResourcesController, type: :controller do
+  controller JsonApiControllerSpec::ResourcesController do
+    def show
+      resource = JsonApiControllerSpec::Resource.new id: 562, name: "Example"
+      json_api resource: resource
+    end
+
+    def index
+      json_api collection: resources
+    end
+
+    def nope
+      json_api error: StandardError.new( "Nope" )
+    end
+
+    def resources
+      @resources ||= [ JsonApiControllerSpec::Resource.new( id: 562, name: "Example" ) ]
+    end
+
+  end
+
+  before( :each ) do
+    allow( controller ).to receive( :_routes ).and_return @routes
+  end
+
+  describe "#json_resource" do
+    subject do
+      get :show, id: 1, format: :json
+      JSON.parse( response.body )
+    end
+
+    it { is_expected.to include "data" => kind_of( Hash ) }
+    it { is_expected.to include "data" => hash_including( "attributes" => kind_of( Hash ) ) }
+
+    it "reflects fields param to meta" do
+      get :show, id: 1, fields: { people: "id,name" }
+      json = JSON.parse( response.body )
+      expect( json ).to include "meta" => hash_including( "fields" )
+    end
+
+    it "fails when 'include' paramter is given" do
+      get :show, id: 1, include: :contact
+
+      expect( response.code ).to eq "400"
+      expect( response.body ).to include "include"
+    end
+  end
+
+  describe "#json_collection" do
+    before( :each ) do
+      allow( controller.resources ).to receive( :current_page ).and_return 1
+    end
+
+    subject do
+      get :index, format: :json
+      JSON.parse( response.body )
+    end
+
+    it { is_expected.to include "data" => kind_of( Array ) }
+    it { is_expected.to include "links" => hash_including( "next" ) }
+  end
+
+  it "writes an error" do
+    routes.draw do
+      get "nope" => "json_api_controller_spec/resources#nope"
+    end
+
+    get :nope
+    json = JSON.parse( response.body )
+
+    expect( json ).to include "errors"
+  end
+
+  describe "#json_context" do
+    it "resolves namespaces from the controller" do
+      expect( controller.send( :json_context_namespaces ) ).to eq [
+        "JsonApiControllerSpec::Resources",
+        "JsonApiControllerSpec"
+      ]
+    end
+  end
+
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: shamu
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.0.4
 platform: ruby
 authors:
 - Paul Alexander
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-04-01 00:00:00.000000000 Z
+date: 2016-04-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activemodel
@@ -273,14 +273,12 @@ files:
 - lib/shamu/json_api/README.md
 - lib/shamu/json_api/base_builder.rb
 - lib/shamu/json_api/context.rb
-- lib/shamu/json_api/entity_serializer.rb
 - lib/shamu/json_api/error.rb
 - lib/shamu/json_api/error_builder.rb
+- lib/shamu/json_api/presenter.rb
 - lib/shamu/json_api/relationship_builder.rb
 - lib/shamu/json_api/resource_builder.rb
 - lib/shamu/json_api/response.rb
-- lib/shamu/json_api/serializer.rb
-- lib/shamu/json_api/support.rb
 - lib/shamu/locale/en.yml
 - lib/shamu/logger.rb
 - lib/shamu/rack.rb
@@ -293,6 +291,7 @@ files:
 - lib/shamu/rails/controller.rb
 - lib/shamu/rails/entity.rb
 - lib/shamu/rails/features.rb
+- lib/shamu/rails/json_api.rb
 - lib/shamu/rails/railtie.rb
 - lib/shamu/rspec.rb
 - lib/shamu/rspec/matchers.rb
@@ -390,6 +389,7 @@ files:
 - spec/lib/shamu/rails/entity_spec.rb
 - spec/lib/shamu/rails/features.yml
 - spec/lib/shamu/rails/features_spec.rb
+- spec/lib/shamu/rails/json_api_spec.rb
 - spec/lib/shamu/security/active_record_policy_spec.rb
 - spec/lib/shamu/security/hashed_value_spec.rb
 - spec/lib/shamu/security/policy_refinement_spec.rb
@@ -424,7 +424,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.3.0
+      version: 2.2.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
@@ -432,7 +432,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.1
+rubygems_version: 2.5.0
 signing_key: 
 specification_version: 4
 summary: Have a whale of a good time adding Service Oriented Architecture to your
@@ -500,6 +500,7 @@ test_files:
 - spec/lib/shamu/rails/entity_spec.rb
 - spec/lib/shamu/rails/features.yml
 - spec/lib/shamu/rails/features_spec.rb
+- spec/lib/shamu/rails/json_api_spec.rb
 - spec/lib/shamu/security/active_record_policy_spec.rb
 - spec/lib/shamu/security/hashed_value_spec.rb
 - spec/lib/shamu/security/policy_refinement_spec.rb

data/lib/shamu/json_api/entity_serializer.rb

@@ -1,10 +0,0 @@
-module Shamu
-  module JsonApi
-
-    # A {Serializer} that can serialize all of the public attributes of an
-    # {Entities::Entity}.
-    class EntitySerializer < Serializer
-
-    end
-  end
-end

data/lib/shamu/json_api/serializer.rb

@@ -1,33 +0,0 @@
-module Shamu
-  module JsonApi
-
-    # Serialize an object to a JSON API stream.
-    class Serializer
-
-      # @param [Object] resource to be serialized.
-      def initialize( resource )
-        @resource = resource
-      end
-
-      # Serialize the {#resource} to the builder.
-      # @param [ResourceBuilder] builder to write to.
-      # @return [void]
-      def serialize( builder )
-      end
-
-      private
-
-        attr_reader :resource
-
-      class << self
-
-        # Find a {Serializer} that knows how to serialize the given resource.
-        # @param [Object] resource to serialize.
-        # @return [Serializer]
-        def find( resource )
-        end
-      end
-
-    end
-  end
-end

data/lib/shamu/json_api/support.rb

@@ -1,8 +0,0 @@
-module Shamu
-  module JsonApi
-
-    # Add the ability to support JSON API serialization.
-    module Support
-    end
-  end
-end