shaf 1.6.0 → 3.0.0

data/lib/shaf/responder/hal.rb

@@ -1,24 +1,85 @@
-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
         type = super
-        type = "#{type};profile=#{profile}" if profile
+        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
 
@@ -16,7 +16,7 @@ module Shaf
 
       def hash
         {
-          status: controller.status,
+          status: status,
           type: code,
           title: title,
           detail: resource.message,

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/router.rb

@@ -1,7 +1,8 @@
 # frozen_string_literal: true
 
-require 'shaf/middleware'
 require 'set'
+require 'sinatra'
+require 'shaf/errors'
 
 module Shaf
   class Router
@@ -21,16 +22,56 @@ module Shaf
       end
     end
 
+    class NullController
+      def call(env)
+        request = request(env)
+        responder = Responder.for(request, error)
+        responder.call(self, error)
+
+        response.finish
+      end
+
+      # Called from responder
+      def content_type(mime)
+        response["Content-Type"] = mime
+      end
+
+      # Called from responder
+      def body(body)
+        response.body  = body
+      end
+
+      private
+
+      def status
+        500
+      end
+
+      def request(env)
+        Sinatra::Request.new(env)
+      end
+
+      def response
+        @response ||= Sinatra::Response.new(nil, status)
+      end
+
+      def error
+        @error ||= Errors::ServerError.new(
+          'Internal error: No controller has been mounted on Router',
+          code: 'NO_MOUNTED_CONTROLLERS',
+          title: 'Shaf::Router must have at least one mounted controller',
+        )
+      end
+    end
+
     class << self
       def mount(controller, default: false)
         @default_controller = controller if default
-        @controllers ||= []
-        @controllers << controller
+        controllers << controller
       end
 
       def routes
-        init_routes unless defined? @routes
-        @routes
+        @routes ||= init_routes
       end
 
       # This controller will be used when no other can handle the request
@@ -41,32 +82,44 @@ module Shaf
 
       private
 
-      attr_reader :controllers
+      def controllers
+        @controllers ||= []
+      end
 
       def init_routes
-        @routes = Hash.new do |hash, key|
+        routes = Hash.new do |hash, key|
           hash[key] = Hash.new { |h, k| h[k] = Set.new }
         end
-        controllers.each { |controller| init_routes_for(controller) }
+        controllers.each { |controller| init(controller, routes) }
+        routes
       end
 
-      def init_routes_for(controller)
+      def init(controller, routes)
         controller.routes.each do |method, controller_routes|
           routes[method][controller] += controller_routes.map(&:first)
         end
       end
     end
 
-    def initialize(app)
+    def initialize(app = NullController.new)
       @app = app
     end
 
     def call(env)
+      # When the api is mounted in Rails then the mount point will be not be
+      # present in PATH_INFO but it will instead be available in SCRIPT_NAME
+      # Shaf need to know about the full path in order to make all path helpers
+      # work, so we need to add the mountpoint back to PATH_INFO.
+      unless String(env['SCRIPT_NAME']).empty?
+        env['PATH_INFO'] = '' if env['PATH_INFO'] == '/'
+        env['PATH_INFO'] = "#{env['SCRIPT_NAME']}#{env['PATH_INFO']}"
+      end
+
       http_method, path = http_details(env)
 
       result = nil
 
-      controllers_for(http_method, path) do |controller|
+      each_controller_for(http_method, path) do |controller|
         result = controller.call(env)
         break unless cascade? result
       end
@@ -80,7 +133,7 @@ module Shaf
       [env['REQUEST_METHOD'], env['PATH_INFO']]
     end
 
-    def controllers_for(http_method, path)
+    def each_controller_for(http_method, path)
       find_cached(http_method, path).each { |ctrlr| yield ctrlr }
 
       if controller = find(http_method, path)

data/lib/shaf/serializer.rb

@@ -0,0 +1,35 @@
+# 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)
+        profile = Profiles.find name
+
+        super { profile&.urn || profile_uri(name) }
+
+        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

data/lib/shaf/spec/authenticator.rb

@@ -0,0 +1,13 @@
+module Shaf
+  module Spec
+    class Authenticator < Shaf::Authenticator::Base
+      scheme 'Test'
+
+      param :realm, required: false
+
+      def self.credentials(authorization, _request)
+        { id: authorization&.to_i }
+      end
+    end
+  end
+end

data/lib/shaf/spec/base.rb

@@ -24,7 +24,7 @@ module Shaf
       end
 
       before do
-        $logger&.info <<~LOG
+        Shaf.log.info <<~LOG
           \n
           ##########################################################################
           # #{self.class.superclass.name} - #{name}

data/lib/shaf/spec/http_method_utils.rb

@@ -7,7 +7,7 @@ module Shaf
 
       %i[get put patch post delete options head link unlink].each do |m|
         define_method m do |uri, payload = nil, options = {}|
-          set_headers
+          set_authentication
 
           if payload
             payload = JSON.generate(payload) if payload.respond_to? :to_h

data/lib/shaf/spec/integration_spec.rb

@@ -8,13 +8,18 @@ module Shaf
 
       register_spec_type self do |_desc, args|
         next unless args&.is_a?(Hash)
-        args[:type]&.to_s == 'integration'
+        args[:type].to_s == 'integration'
       end
 
-      def set_headers
-        if defined?(@__integration_test_auth_token) && @__integration_test_auth_token
-          header Settings.auth_token_header, @__integration_test_auth_token
-        end
+      private
+
+      attr_accessor :__authenticated_user_id
+
+      def set_authentication
+        id = __authenticated_user_id
+        authorization = "#{Authenticator.scheme} #{id}" if id
+
+        header 'Authorization', authorization
       end
 
       def parse_response(body)
@@ -25,7 +30,22 @@ module Shaf
       end
 
       def app
-        App.app
+        App.instance
+      end
+
+      def authenticate(user)
+        self.__authenticated_user_id = user&.id
+      end
+
+      def unauthenticate
+        self.__authenticated_user_id = nil
+      end
+
+      def with_authenticated(user, &block)
+        authenticate(user)
+        yield
+      ensure
+        unauthenticate
       end
 
       def follow_rel(rel, method: nil)
@@ -37,14 +57,6 @@ module Shaf
           get link[:href]
         end
       end
-
-      def auth_token(token)
-        @__integration_test_auth_token = token
-      end
-
-      def clear_auth_token
-        @__integration_test_auth_token = nil
-      end
     end
   end
 end

data/lib/shaf/spec/payload_utils.rb

@@ -29,11 +29,11 @@ module Shaf
         last_payload[:_embedded]&.keys || []
       end
 
-      def embedded(name = nil)
+      def embedded(name = nil, &block)
         assert_has_embedded name unless name.nil?
         keys = [:_embedded, name&.to_sym].compact
         return last_payload.dig(*keys) unless block_given?
-        exec_embed_block(last_payload.dig(*keys), Proc.new)
+        exec_embed_block(last_payload.dig(*keys), block)
       end
 
       def each_embedded(name, &block)

data/lib/shaf/spec.rb

@@ -6,3 +6,4 @@ require 'shaf/spec/base'
 require 'shaf/spec/integration_spec'
 require 'shaf/spec/serializer_spec'
 require 'shaf/spec/system_spec'
+require 'shaf/spec/authenticator'

data/lib/shaf/supported_http_methods.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Shaf
+  SUPPORTED_HTTP_METHODS = [
+    :get,
+    :put,
+    :post,
+    :patch,
+    :delete,
+    :head,
+    :options,
+    :link,
+    :unlink
+  ]
+end

data/lib/shaf/tasks/routes_task.rb

@@ -1,29 +1,26 @@
 module Shaf
   module Tasks
     class RoutesTask
-      include Rake::DSL
+      extend Rake::DSL
 
-      def initialize(*)
-        desc "List path helpers"
-        task :routes do
-          require 'shaf/utils'
-          require 'config/database'
+      desc 'List path helpers'
+      task :routes do
+        require 'shaf/utils'
+        require 'config/database'
 
-          extend Shaf::Utils
-          bootstrap
+        extend Shaf::Utils
+        bootstrap
 
-          helpers = UriHelperMethods.path_helpers_for.sort { |a, b| a[0].to_s <=> b[0].to_s }
-          helpers.each do |controller, methods|
-            puts "\n#{controller}:"
-            methods.each do |method|
-              template_method = "#{method}_template".to_sym
-              puts sprintf( "%-60s%s" , method, controller.send(template_method))
-            end
+        Shaf::ApiRoutes::Registry.controllers.each do |controller|
+          puts "\n#{controller}:"
+          Shaf::ApiRoutes::Registry.routes_for(controller) do |methods, template, symbol|
+            puts format(
+              '  %-50<symbol>s%-30<methods>s%<template>s',
+              {symbol: symbol, methods: methods.join(' | '), template: template}
+            )
           end
         end
       end
     end
-
-    RoutesTask.new
   end
 end

data/lib/shaf/tasks.rb

@@ -1,6 +1,5 @@
 require 'shaf/tasks/test_task'
 require 'shaf/tasks/db_task'
-require 'shaf/tasks/api_doc_task'
 require 'shaf/tasks/routes_task'
 
 module Shaf