shaf 1.6.1 → 2.0.0

data/lib/shaf/responder.rb

@@ -1,7 +1,10 @@
 require 'set'
+require 'shaf/errors'
 
 module Shaf
   module Responder
+    MEDIA_TYPE_SUFFIX_PATTERN = %r{(.*)/([^+]+)\+(.*)}.freeze
+
     class << self
       def register(responder)
         uninitialized << responder
@@ -15,15 +18,23 @@ module Shaf
       end
 
       def for(request, resource)
+        return Responder::ProblemJson if resource.is_a?(Errors::NotAcceptableError)
+
         types = supported_responders_for(resource).map(&:mime_type)
-        mime = request.preferred_type(types)
-        responders[mime]
+        types = move_html_to_last(types)
+
+        mime = preferred_type(request, types)
+        responders[mime] or raise Errors::NotAcceptableError
       end
 
       def default=(responder)
         responders.default = responder
       end
 
+      def default
+        responders.default
+      end
+
       private
 
       def supported_responders_for(resource)
@@ -41,6 +52,23 @@ module Shaf
         @supported_responders ||= Hash.new { |hash, key| hash[key] = Set.new }
       end
 
+      def preferred_type(request, types)
+        mime = request.preferred_type(types)
+        return mime if mime
+
+        request.accept.find do |accept|
+          next if accept.match? MEDIA_TYPE_SUFFIX_PATTERN
+
+          types.find do |type|
+            m = type.match MEDIA_TYPE_SUFFIX_PATTERN
+            next unless m
+
+            format = "#{m[1]}/#{m[3]}"
+            return type if accept.to_str == format
+          end
+        end
+      end
+
       def uninitialized
         @uninitialized ||= []
       end
@@ -57,6 +85,16 @@ module Shaf
           init_responders!
         end
       end
+
+      # We want to always be able to respond with text/html, but only when
+      # asked for (Accept header) to be able to let other more specific mime
+      # types take precedence we need to move text/html to the end of the
+      # array.
+      def move_html_to_last(types)
+        return types unless types.include? Html.mime_type
+
+        (types - [Html.mime_type]) << Html.mime_type
+      end
     end
   end
 end
@@ -65,3 +103,4 @@ require 'shaf/responder/base'
 require 'shaf/responder/hal'
 require 'shaf/responder/html'
 require 'shaf/responder/problem_json'
+require 'shaf/responder/alps_json'

data/lib/shaf/responder/alps_json.rb

@@ -0,0 +1,25 @@
+require 'shaf/alps/json_serializer'
+
+module Shaf
+  module Responder
+    class AlpsJson < Base
+      mime_type :alps_json, 'application/alps+json'
+
+      def self.can_handle?(resource)
+        return false unless resource.is_a? Class
+        resource <= Shaf::Profile
+      end
+
+      def body
+        JSON.generate hash
+      end
+
+      private
+
+      def hash
+        ALPS::JsonSerializer.call(resource)
+      end
+    end
+  end
+end
+

data/lib/shaf/responder/base.rb

@@ -2,12 +2,14 @@ module Shaf
   module Responder
     class Response
       attr_reader :content_type, :body, :serialized_hash, :resource
+      attr_accessor :preload_links
 
       def initialize(content_type:, body:, serialized_hash: {}, resource: nil)
         @content_type = content_type
         @body = body
         @serialized_hash = serialized_hash
         @resource = resource
+        @preload_links = []
       end
 
       def log_entry
@@ -36,11 +38,10 @@ module Shaf
         end
 
         def call(controller, resource, preload: [], **kwargs)
-          responder = new(controller, resource, **kwargs)
+          responder = new(controller, resource, preload_rels: preload, **kwargs)
           response = responder.build_response
           log_response(controller, response)
-          preload_links = preload_links(preload, responder, response, controller)
-          write_response(controller, response, preload_links)
+          write_response(controller, response)
         end
 
         def can_handle?(_obj)
@@ -58,23 +59,14 @@ module Shaf
           controller.log.send(type, msg)
         end
 
-        def preload_links(rels, responder, response, controller = nil)
-          Array(rels).map do |rel|
-            links = responder.lookup_rel(rel, response)
-            links = [links].compact unless links.is_a? Array
-            log(controller, PRELOAD_FAILED_MSG % rel) if links.empty?
-            links
-          end
-        end
-
-        def write_response(controller, response, preload_links)
+        def write_response(controller, response)
           controller.content_type(response.content_type)
-          add_preload_links(controller, response, preload_links)
+          add_preload_links(controller, response)
           controller.body(response.body)
         end
 
-        def add_preload_links(controller, response, preload_links)
-          preload_links.each do |links|
+        def add_preload_links(controller, response)
+          response.preload_links.each do |links|
             links.each do |link|
               next unless link[:href]
               # Nginx http2_push_preload only processes relative URIs with absolute path
@@ -111,9 +103,20 @@ module Shaf
           body: body,
           serialized_hash: serialized_hash,
           resource: resource
-        )
+        ).tap do |response|
+          response.preload_links = preload_links(response)
+        end
       end
 
+        def preload_links(response)
+          Array(options[:preload_rels]).map do |rel|
+            links = lookup_rel(rel, response)
+            links = [links].compact unless links.is_a? Array
+            log(controller, PRELOAD_FAILED_MSG % rel) if links.empty?
+            links
+          end
+        end
+
       def lookup_rel(_rel, _response)
         []
       end

data/lib/shaf/responder/hal.rb

@@ -1,17 +1,37 @@
-require 'shaf/responder/hal_serializable'
-
 module Shaf
   module Responder
     class Hal < Base
-      include HalSerializable
-
       use_as_default!
       mime_type :hal, 'application/hal+json'
 
+      def self.can_handle?(resource)
+        return false if resource.is_a? StandardError
+
+        if resource.is_a? Class
+          return false if resource <= Shaf::Profile
+        end
+
+        true
+      end
+
       def body
         @body ||= generate_json
       end
 
+      def lookup_rel(rel, response)
+        hal = response.serialized_hash
+        links = hal&.dig(:_links, rel.to_sym)
+        return [] unless links
+
+        links = [links] unless links.is_a? Array
+        links.map do |link|
+          {
+            href: link[:href],
+            as: 'fetch',
+            crossorigin: 'anonymous'
+          }
+        end
+      end
       private
 
       def mime_type
@@ -19,6 +39,47 @@ module Shaf
         type = "#{type};profile=#{profile}" if profile
         type
       end
+
+      def collection?
+        !!options.fetch(:collection, false)
+      end
+
+      def serializer
+        @serializer ||= options[:serializer] || HALPresenter.lookup_presenter(resource)
+      end
+
+      def serialized_hash
+        raise Errors::NotAcceptableError unless serializer
+
+        @serialized_hash ||=
+          if collection?
+            serializer.to_collection(resource, current_user: user, as_hash: true, **options)
+          else
+            serializer.to_hal(resource, current_user: user, as_hash: true, **options)
+          end
+
+        # hal_presenter versions before v1.5.0 does not understand the :as_hash
+        # keyword argument and will always return a String from
+        # to_hal/to_collection, thus we need to parse it if its a String.
+        if @serialized_hash.is_a? String
+          @body = @serialized_hash
+          @serialized_hash = JSON.parse(@serialized_hash, symbolize_names: true)
+        end
+
+        @serialized_hash
+      end
+
+      def profile
+        @profile ||= options[:profile]
+        return unless @profile || serializer
+
+        @profile ||= serializer.semantic_profile
+      end
+
+      def generate_json
+        # FIXME: change to Oj??
+        JSON.generate(serialized_hash)
+      end
     end
   end
 end

data/lib/shaf/responder/html.rb

@@ -1,14 +1,50 @@
-require 'shaf/responder/hal_serializable'
-
 module Shaf
   module Responder
     class Html < Base
-      include HalSerializable
-
       mime_type :html
 
+      class << self
+        def call(controller, resource, preload: [], **kwargs)
+          responder = responder_for(resource, controller, preload_rels: preload, **kwargs)
+          response = responder.build_response
+          add_preload_links(controller, response)
+
+          html_responder = new(controller, resource, response: response)
+          html_response = html_responder.build_response
+          log_response(controller, response)
+
+          write_response(controller, html_response)
+        end
+
+
+        # Returns the "original" (non-html) responder
+        def responder_for(resource, controller, **kwargs)
+          responders = Responder.send(:supported_responders_for, resource)
+          responder_class = (responders - [self]).first || Responder.default
+          responder_class.new(controller, resource, **kwargs)
+        end
+      end
+
       def body
-        locals = variables
+        response = options[:response]
+        serialized = response.serialized_hash
+        if serialized.empty?
+          serialized = begin
+                         JSON.parse(response.body)
+                       rescue StandardError
+                         response.body
+                       end
+        end
+
+        render serialized
+      end
+
+      def render(serialized)
+        locals = {
+          request_headers: request_headers,
+          response_headers: response_headers,
+          serialized: serialized
+        }
 
         template =
           case resource
@@ -22,25 +58,16 @@ module Shaf
         controller.erb(template, locals: locals)
       end
 
-      def variables
-        {
-          request_headers: request_headers,
-          response_headers: response_headers,
-          serialized: serialized_hash
-        }
-      end
-
       def request_headers
         controller.request_headers
       end
 
       def response_headers
-        etag, kind = controller.send(:etag_for, generate_json)
+        etag, kind = controller.send(:etag_for, options[:response].body)
         prefix = kind == :weak ? 'W/' : ''
         etag = %Q{#{prefix}"#{etag}"}
 
-        type = Hal.mime_type
-        type = "#{type};profile=#{profile}" if profile
+        type = options[:response].content_type
 
         controller.headers.merge('Content-Type' => type, 'ETag' => etag)
       end

data/lib/shaf/responder/problem_json.rb

@@ -4,7 +4,7 @@ module Shaf
       mime_type :problem_json, 'application/problem+json'
 
       def self.can_handle?(resource)
-        klass = resource.is_a?(Class) ? resource: resource.class
+        klass = resource.is_a?(Class) ? resource : resource.class
         klass <= StandardError
       end
 

data/lib/shaf/serializer.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require 'hal_presenter'
+
+module Shaf
+  # A base class used for serializing objects into a HAL representations.
+  class Serializer
+    extend HALPresenter
+    extend UriHelper
+
+    class << self
+      attr_reader :default_curie_prefix
+
+      # Creates a link with rel profile and href pointing to the corresponding profile.
+      # It also adds a Curie link.
+      # @param name [String] the name of the profile
+      # @param curie_prefix [Symbol] the prefix used for the Curie
+      def profile(name, curie_prefix: :doc)
+        link :profile do
+          profile_uri(name)
+        end
+
+        curie curie_prefix do
+          doc_curie_uri(name)
+        end
+
+        @default_curie_prefix = curie_prefix.to_sym
+      end
+    end
+  end
+end

data/lib/shaf/settings.rb

@@ -12,24 +12,41 @@ module Shaf
       documents_dir: 'doc/api',
       migrations_dir: 'db/migrations',
       fixtures_dir: 'spec/fixtures',
-      auth_token_header: 'X-Auth-Token',
       paginate_per_page: 25
     }.freeze
 
     class << self
-      def load
-        @settings = DEFAULTS.dup
-        config = Utils.read_config(SETTINGS_FILE, erb: true)
-        @settings.merge! config.fetch(env, {})
+      def env
+        (ENV['APP_ENV'] || ENV['RACK_ENV'] || 'development').to_sym
       end
 
+      def key?(key)
+        settings.key? key
+      end
 
-      def env
-        (ENV['APP_ENV'] || ENV['RACK_ENV'] || 'development').to_sym
+      def to_h
+        settings.dup
+      end
+
+      def loaded?
+        !!defined? @settings
+      end
+
+      private
+
+      def settings
+        load_config unless loaded?
+        @settings
+      end
+
+      def load_config
+        @settings = DEFAULTS.dup
+        config = Utils.read_config(SETTINGS_FILE, erb: true)
+        @settings.merge! config.fetch(env, {})
       end
 
       def method_missing(method, *args)
-        load unless defined? @settings
+        load_config unless loaded?
 
         if method.to_s.end_with? '='
           define_setter(method)
@@ -56,10 +73,6 @@ module Shaf
           @settings[key] = arg
         end
       end
-
-      def to_h
-        @settings.dup
-      end
     end
   end
 end