shaf 1.3.0 → 1.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 319f7f6a1725c5e3e5d9ab293531dc72cced237cf5967d2beb3ef3f47c5be8e7
-  data.tar.gz: 4f37d5e9c0424c31c6dda4ec2c5e628920963d01dd61d367681504cd6f50f0e0
+  metadata.gz: d6502c5b061eb5e2420e621d91a12866f4d5c8a2a295c8d2b129df12a71d6668
+  data.tar.gz: 19b4fa57c6b99c69b084b493769dd7291253a9f62e7d0607c5ffdcf8f24f8549
 SHA512:
-  metadata.gz: 3431790d086472d8cbac8ec9e51ed8fb02ddc4a402ec993a5ed7d17ea1eb048e89902693b3c4c3f88a3630c226fddc175dd4c0024136cac4adb43cd4d2869531
-  data.tar.gz: 004321671f62d6578e35c42ed1a1b3b1345bc9308743710dc5cc645195303af8235e30d4288ec6f8048c3ad7ab04ca6087912d27ea983b5ecc45768b997b6347
+  metadata.gz: d7c299b50eb8b8b62c7dd1ab4b5ebff9f85f1dc286a858ce7a0925e1a7ef30fd4639303b9293c79971118b7a80c2582f0142f063ef131511ab645138bf0c7b44
+  data.tar.gz: 93b4102fb1b5efd7fe020eab71522ff314a343ee3e67ed19b7a2cdad6b9243188c60b7d56a5ce1c0bb10746045e8f8a2842247880717e8951eae47c622ea806a

checksums.yaml.gz.sig

@@ -1,4 +1 @@
-x��=����3.��
-p?�2,x�)���F#�
-
-OWO���א�ൠ4T�pDkZ�|ߌJ�;��,�ZgB|i:�8���l�y��Ԣ\u�.Ԛ]%D��,zy���Pr�<���B+���XC�p�,yޝԒ�wM�1�<x�
M�KvK�H�VӤ��iC<;e�F��0#�G]3r�;{X�͕)<�Gң���I�
+8u�j^��tyAߘ������u�dHzxJ��� �5�2|��/Ț�!v�IW?Y��h
�������~�N������8�>i�

data/lib/shaf/helpers/payload.rb

@@ -1,28 +1,12 @@
 # frozen_string_literal: true
 
 require 'set'
+require 'shaf/responder'
 
 module Shaf
   module Payload
     EXCLUDED_FORM_PARAMS = ['captures', 'splat'].freeze
 
-    def supported_response_types(resource)
-      [
-        mime_type(:hal),
-        mime_type(:json),
-        mime_type(:html)
-      ]
-    end
-
-    def preferred_response_type(resource)
-      supported_types = supported_response_types(resource)
-      request.preferred_type(supported_types)
-    end
-
-    def prefer_html?
-      request.preferred_type.to_s == mime_type(:html)
-    end
-
     private
 
     def payload
@@ -95,58 +79,31 @@ module Shaf
     def respond_with(resource, status: 200, serializer: nil, collection: false, **kwargs)
       status(status)
 
-      preferred_response = preferred_response_type(resource)
-      http_cache = kwargs.delete(:http_cache) { Settings.http_cache }
-
-      serializer ||= HALPresenter.lookup_presenter(resource)
-      serialized = serialize(resource, serializer, collection, **kwargs)
-      add_cache_headers(serialized) if http_cache
+      kwargs.merge!(
+        profile: profile,
+        serializer: serializer,
+        collection: collection
+      )
 
       log.info "#{request.request_method} #{request.path_info} => #{status}"
-
-      if preferred_response == mime_type(:html)
-        respond_with_html(resource, serialized)
+      payload = Responder.for(request, resource).call(self, resource, **kwargs)
+      add_cache_headers(payload, kwargs)
+    rescue StandardError => err
+      log.error "Failure: #{err.message}\n#{err.backtrace}"
+      if status == 500
+        content_type mime_type(:json)
+        body JSON.generate(failure: err.message)
       else
-        respond_with_hal(resource, serialized, serializer)
+        respond_with(Errors::ServerError.new(err.message), status: 500)
       end
     end
 
-    def serialize(resource, serializer, collection, **options)
-      if collection
-        serializer.to_collection(resource, current_user: current_user, **options)
-      else
-        serializer.to_hal(resource, current_user: current_user, **options)
-      end
-    end
-
-    def respond_with_hal(resource, serialized, serializer)
-      log.debug "Response payload (#{resource.class}): #{serialized}"
-      content_type :hal, content_type_params(serializer)
-      body serialized
-    end
-
-    def respond_with_html(resource, serialized)
-      log.debug "Responding with html. Output payload (#{resource.class}): #{serialized}"
-      content_type :html
-      case resource
-      when Formable::Form
-        body erb(:form, locals: {form: resource, serialized: serialized})
-      else
-        body erb(:payload, locals: {serialized: serialized})
-      end
-    end
-
-    def add_cache_headers(payload)
+    def add_cache_headers(payload, kwargs)
+      return unless kwargs.delete(:http_cache) { Settings.http_cache }
       return if payload.nil? || payload.empty?
 
       sha1 = Digest::SHA1.hexdigest payload
       etag sha1, :weak # Weak or Strong??
     end
-
-    def content_type_params(serializer)
-      return {profile: profile} if profile
-
-      {profile: serializer.semantic_profile}.compact
-    end
   end
 end

data/lib/shaf/responder.rb

@@ -0,0 +1,67 @@
+require 'set'
+
+module Shaf
+  module Responder
+    class << self
+      def register(responder)
+        uninitialized << responder
+      end
+
+      def unregister(responder)
+        responders.delete_if { |_, r| r == responder }
+        supported_responders.each do |_klass, responders|
+          responders.delete_if { |r| r == responder }
+        end
+      end
+
+      def for(request, resource)
+        types = supported_responders_for(resource).map(&:mime_type)
+        mime = request.preferred_type(types)
+        responders[mime]
+      end
+
+      def default=(responder)
+        responders.default = responder
+      end
+
+      private
+
+      def supported_responders_for(resource)
+        klass = resource.is_a?(Class) ? resource: resource.class
+        if supported_responders[klass].empty?
+          responders.each do |_mime, responder|
+            next unless responder.can_handle? resource
+            supported_responders[klass] << responder
+          end
+        end
+        supported_responders[klass].to_a
+      end
+
+      def supported_responders
+        @supported_responders ||= Hash.new { |hash, key| hash[key] = Set.new }
+      end
+
+      def uninitialized
+        @uninitialized ||= []
+      end
+
+      def init_responders!
+        while responder = uninitialized.shift
+          mime = responder.mime_type
+          @responders[mime] = responder
+        end
+      end
+
+      def responders
+        (@responders ||= {}).tap do
+          init_responders!
+        end
+      end
+    end
+  end
+end
+
+require 'shaf/responder/base'
+require 'shaf/responder/hal'
+require 'shaf/responder/html'
+require 'shaf/responder/problem_json'

data/lib/shaf/responder/base.rb

@@ -0,0 +1,112 @@
+module Shaf
+  module Responder
+    class Response
+      attr_reader :content_type, :body, :resource, :serialized
+
+      def initialize(content_type, body, resource, serialized = nil)
+        @content_type = content_type
+        @body = body
+        @resource = resource
+        @serialized = serialized
+      end
+    end
+
+    class Base
+      class << self
+        def mime_type(type = nil, value = nil)
+          if type
+            @mime_type = type
+            @mime_type = Sinatra::Base.mime_type(type, value) if type.is_a? Symbol
+            Responder.register(self)
+          elsif defined? @mime_type
+            @mime_type
+          else
+            raise Error, "Class #{self} must register a mime type"
+          end
+        end
+
+        def use_as_default!
+          Responder.default = self
+        end
+
+        def call(controller, resource, **kwargs)
+          responder = new(controller, resource, **kwargs)
+          response = responder.response
+          log_response(controller, response)
+          write_response(controller, response)
+        end
+
+        def can_handle?(_obj)
+          true
+        end
+
+        private
+
+        def log_response(controller, response)
+          return unless controller.respond_to? :log
+
+          controller.log.debug(
+            "Response (#{response.resource.class}) payload: #{response.serialized}"
+          )
+        end
+
+        def write_response(controller, response)
+          controller.content_type(response.content_type)
+          controller.body(response.body)
+        end
+      end
+
+      attr_reader :controller, :resource, :options
+
+      def initialize(controller, resource, **options)
+        @controller = controller
+        @resource = resource
+        @options = options
+      end
+
+      def body
+        raise NotImplementedError, "#{self.class} must implement #body"
+      end
+
+      def serialized
+        @serialize
+      end
+
+      def response
+        Response.new(mime_type, body, resource, serialized)
+      end
+
+      private
+
+      def mime_type
+        self.class.mime_type
+      end
+
+      def collection?
+        !!options.fetch(:collection, false)
+      end
+
+      def user
+        options.fetch(:current_user) do
+          controller.current_user if controller.respond_to? :current_user
+        end
+      end
+
+      def serializer
+         @serializer ||= options[:serializer] || HALPresenter.lookup_presenter(resource)
+      end
+
+      def serialize
+        return "" unless serializer
+
+        @serialize ||=
+          if collection?
+            serializer.to_collection(resource, current_user: user, **options)
+          else
+            serializer.to_hal(resource, current_user: user, **options)
+          end
+      end
+    end
+  end
+end
+

data/lib/shaf/responder/hal.rb

@@ -0,0 +1,24 @@
+module Shaf
+  module Responder
+    class Hal < Base
+      mime_type :hal, 'application/hal+json'
+      use_as_default!
+
+      def body
+        serialize
+      end
+
+      private
+
+      def mime_type
+        type = super
+        type = "#{type};profile=#{profile}" if profile
+        type
+      end
+
+      def profile
+        @profile ||= options[:profile] || serializer.semantic_profile
+      end
+    end
+  end
+end

data/lib/shaf/responder/html.rb

@@ -0,0 +1,16 @@
+module Shaf
+  module Responder
+    class Html < Base
+      mime_type :html
+
+      def body
+        case resource
+        when Formable::Form
+          controller.erb(:form, locals: {form: resource, serialized: serialize})
+        else
+          controller.erb(:payload, locals: {serialized: serialize})
+        end
+      end
+    end
+  end
+end

data/lib/shaf/responder/problem_json.rb

@@ -0,0 +1,43 @@
+module Shaf
+  module Responder
+    class ProblemJson < Base
+      mime_type :problem_json, 'application/problem+json'
+
+      def self.can_handle?(resource)
+        klass = resource.is_a?(Class) ? resource: resource.class
+        klass <= StandardError
+      end
+
+      def body
+        JSON.generate(hash)
+      end
+
+      private
+
+      def hash
+        {
+          status: controller.status,
+          type: code,
+          title: title,
+          detail: resource.message,
+        }
+      end
+
+      def status
+        return resource.http_status if resource.respond_to? :http_status
+        controller.status
+      end
+
+      def code
+        return resource.code if resource.respond_to? :code
+        'about:blank'
+      end
+
+      def title
+        return resource.title if resource.respond_to? :title
+        resource.class.to_s
+      end
+    end
+  end
+end
+

data/lib/shaf/router.rb

@@ -5,6 +5,22 @@ require 'set'
 
 module Shaf
   class Router
+    class MethodNotAllowedResponder
+      attr_reader :supported_methods
+
+      def initialize(supported_methods)
+        @supported_methods = supported_methods
+      end
+
+      def allowed
+        supported_methods.join(', ')
+      end
+
+      def call(env)
+        [405, {'Allow' => allowed}, '']
+      end
+    end
+
     class << self
       def mount(controller, default: false)
         @default_controller = controller if default
@@ -28,13 +44,14 @@ module Shaf
       attr_reader :controllers
 
       def init_routes
-        @routes = {}
+        @routes = Hash.new do |hash, key|
+          hash[key] = Hash.new { |hash, key| hash[key] = Set.new }
+        end
         controllers.each { |controller| init_routes_for(controller) }
       end
 
       def init_routes_for(controller)
         controller.routes.each do |method, controller_routes|
-          routes[method] ||= Hash.new { |hash, key| hash[key] = [] }
           routes[method][controller] += controller_routes.map(&:first)
         end
       end
@@ -74,6 +91,11 @@ module Shaf
         yield ctrlr unless ctrlr == controller
       end
 
+      supported_methods = supported_methods_for(path)
+      if !supported_methods.empty? && !supported_methods.include?(http_method)
+        yield MethodNotAllowedResponder.new(supported_methods)
+      end
+
       yield default_controller
     end
 
@@ -105,6 +127,17 @@ module Shaf
       end
     end
 
+    def supported_methods_for(path)
+      methods = Set.new
+      routes.each do |http_method, controllers|
+        controllers.each do |_, patterns|
+          next unless patterns.any? { |pattern| pattern.match(path) }
+          methods << http_method
+        end
+      end
+      methods.to_a
+    end
+
     def cascade?(result)
       result.dig(1, 'X-Cascade') == 'pass'
     end
@@ -114,6 +147,8 @@ module Shaf
     end
 
     def add_cache(controller, http_method, path)
+      return unless controller
+
       key = cache_key(http_method, path)
       cache[key] << controller
     end

data/lib/shaf/version.rb

@@ -1,3 +1,3 @@
 module Shaf
-  VERSION = "1.3.0"
+  VERSION = "1.4.0"
 end

data/templates/api/controllers/base_controller.rb

@@ -6,7 +6,6 @@ class BaseController < Sinatra::Base
     disable :static
     enable :logging
     enable :method_override
-    mime_type :hal, 'application/hal+json'
     set :views, Shaf::Settings.views_folder
     set :static, !production?
     set :public_folder, Shaf::Settings.public_folder
@@ -38,6 +37,7 @@ class BaseController < Sinatra::Base
 
   before do
     log.info "Processing: #{request.request_method} #{request.path_info}"
+    log.debug "Headers: #{request_headers}"
     log.debug "Payload: #{payload || 'empty'}"
     set_vary_header
   end

data/templates/api/serializers/documentation_serializer.rb

@@ -17,8 +17,9 @@ class DocumentationSerializer < BaseSerializer
       hash[attr] = resource.attribute(attr)
     else
       hash[:attributes] = resource.attributes
-      hash[:rels] = resource.links
-      hash[:embeds] = resource.embeds
+      hash[:relations] = resource.links
+      embeds = resource.embeds
+      hash[:embedded_resources] = embeds unless embeds.empty?
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: shaf
 version: !ruby/object:Gem::Version
-  version: 1.3.0
+  version: 1.4.0
 platform: ruby
 authors:
 - Sammy Henningsson
@@ -30,7 +30,7 @@ cert_chain:
   ZMhjYR7sRczGJx+GxGU2EaR0bjRsPVlC4ywtFxoOfRG3WaJcpWGEoAoMJX6Z0bRv
   M40=
   -----END CERTIFICATE-----
-date: 2019-10-24 00:00:00.000000000 Z
+date: 2019-11-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest
@@ -136,6 +136,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.5'
+- !ruby/object:Gem::Dependency
+  name: faraday
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.17'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.17'
 description: A framework for building hypermedia driven APIs with sinatra and sequel.
 email: sammy.henningsson@gmail.com
 executables:
@@ -213,6 +227,11 @@ files:
 - lib/shaf/rake/test.rb
 - lib/shaf/registrable_factory.rb
 - lib/shaf/resource_doc.rb
+- lib/shaf/responder.rb
+- lib/shaf/responder/base.rb
+- lib/shaf/responder/hal.rb
+- lib/shaf/responder/html.rb
+- lib/shaf/responder/problem_json.rb
 - lib/shaf/router.rb
 - lib/shaf/settings.rb
 - lib/shaf/spec.rb
@@ -280,6 +299,7 @@ files:
 - upgrades/1.2.0.tar.gz
 - upgrades/1.2.1.tar.gz
 - upgrades/1.3.0.tar.gz
+- upgrades/1.4.0.tar.gz
 homepage: 
 licenses:
 - MIT