linked_rails 0.0.3 → 0.0.4.pre.g0ec6e30ca

data/lib/linked_rails/controller/actionable.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+require_relative 'default_actions/create'
+require_relative 'default_actions/destroy'
+require_relative 'default_actions/update'
+
+module LinkedRails
+  module Controller
+    module Actionable
+      ACTION_METHOD_MAPPING = {
+        execute: :execute,
+        on_failure: :failure,
+        on_success: :success
+      }.freeze
+
+      extend ActiveSupport::Concern
+
+      included do
+        extend LinkedRails::Controller::DefaultActions::Create
+        extend LinkedRails::Controller::DefaultActions::Destroy
+        extend LinkedRails::Controller::DefaultActions::Update
+      end
+
+      class_methods do
+        def has_collection_action(action, **opts)
+          has_action(:collection, action, **opts)
+        end
+
+        def has_singular_action(action, **opts)
+          has_action(:singular, action, **opts)
+        end
+
+        def has_resource_action(action, **opts)
+          has_action(:resource, action, **opts)
+        end
+
+        private
+
+        # @param [:resource, :singular, :collection] type To which action list the action is added
+        # @param [symbol] action_key A key to identify the action
+        # @param [Hash] opts The options for the action
+        # @option opts [symbol] :action_name The name for the controller action for GETting this action.
+        #   A route is automatically generated. Defaults to the action key
+        # @option opts [proc<string>, string] :action_path The path to be appended to the resource iri.
+        #   Defaults to "#{action_key}_action"
+        # @option opts [proc<string>, string] :description The description of this action
+        # @option opts [symbol] :execute The controller method to use when this action is executed.
+        #   Defaults to "#{action}_execute"
+        # @option opts [proc<boolean>, boolean] :favorite Whether or not this is a favorite action
+        # @option opts [proc<LinkedRails::Form>, LinkedRails::Form] :form The form for this action
+        # @option opts [proc<string>, string] :http_method The method to be used in the request.
+        #   GET, HEAD, POST, PUT, DELETE, CONNECT, OPTIONS, TRACE, PATCH
+        #   Defaults to POST
+        # @option opts [proc<string>, string] :image A fontawesome icon, prepended with 'fa-'
+        # @option opts [boolean] :inherit Whether descendant controllers should clone this action.
+        #   Defaults to true
+        # @option opts [boolean] :one_click Whether the action can be executed with one click.
+        #   Defaults to false
+        # @option opts [proc<string>, string] :label The label of the action
+        # @option opts [LinkedRails::Model] :object The object on which the action will be executed
+        #   Defaults to the resource
+        # @option opts [symbol] :on_failure Callback when the execute method failed.
+        #   Defaults to "#{action}_failure"
+        # @option opts [symbol] :on_success Callback when the execute method succeeded.
+        #   Defaults to "#{action}_success"
+        # @option opts [symbol] :policy The method to be called on the policy of the policy_resource
+        # @option opts [Array<symbol>] :policy_arguments The arguments passed to the policy method
+        # @option opts [proc<LinkedRails::Model>, LinkedRails::Model] :policy_resource
+        #   The resource on which a policy needs to be authorized.
+        #   Defaults to the object
+        # @option opts [proc<RDF::URI>, RDF::URI] :predicate The relation between the resource and the action
+        # @option opts [proc<LinkedRails::Model>, LinkedRails::Model] :result
+        # @option opts [proc<string>, string] :submit_label The label for the submit button of the action
+        # @option opts [proc<string>, string] :target_url The url whereto the request will be made.
+        #   Use target_path/target_query  when the url starts with the iri of the resource, so a route can be generated.
+        # @option opts [string] :target_path The path appended to the iri of the resource to determine
+        #   the url whereto the request will be made. A route is automatically generated.
+        #   Defaults to the action key
+        # @option opts [hash] :target_query The query appended to the iri of the resource to determine
+        # @option opts [array<RDF::URI>, RDF::URI] :type The rdf type of the action.
+        #   Defaults to schema.UpdateAction
+        def has_action(type, action_key, opts)
+          opts[:action_name] ||= "#{action_key}_action"
+          opts[:http_method] ||= 'POST'
+          opts[:target_path] ||= action_key if opts[:target_url].blank?
+
+          active_response(action_key, opts[:action_name])
+          define_action_show_method(action_key, opts)
+          define_action_execute_methods(action_key, opts)
+          controller_class.action_list.defined_actions[type][action_key] = opts
+        end
+
+        def define_action_execute_methods(action_key, opts)
+          ACTION_METHOD_MAPPING.each do |key, value|
+            define_action_execute_method(action_key, key, value, opts)
+          end
+        end
+
+        def define_action_execute_method(action, key, suffix, opts)
+          call_method = opts.delete(key)
+          method_name = :"#{action}_#{suffix}"
+          return if call_method.blank? || method_name == call_method
+
+          define_method(method_name) do
+            if call_method.is_a?(Symbol)
+              send(call_method)
+            else
+              instance_exec(&call_method)
+            end
+          end
+        end
+
+        def define_action_show_method(_action, opts)
+          define_method("#{opts[:action_name]}_success") do
+            respond_with_resource(show_success_options)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/linked_rails/controller/authorization.rb

@@ -6,10 +6,16 @@ module LinkedRails
       extend ActiveSupport::Concern
 
       def authorize_action
+        return authorize_action_item if current_resource!.is_a?(LinkedRails.actions_item_class)
+
         query = action_name == 'index' ? :show? : "#{params[:action].chomp('!')}?"
 
         authorize(current_resource!, query)
       end
+
+      def authorize_action_item
+        authorize(current_resource!.resource, :show?) if current_resource!.resource
+      end
     end
   end
 end

data/lib/linked_rails/controller/default_actions/create.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module LinkedRails
+  module Controller
+    module DefaultActions
+      module Create
+        def has_collection_create_action(**overwrite)
+          has_collection_action(:create, **create_collection_options(**overwrite))
+        end
+
+        def has_singular_create_action(**overwrite)
+          has_singular_action(:create, **create_singular_options(**overwrite))
+        end
+
+        private
+
+        def create_collection_options(**overwrite)
+          default_create_options(
+            form: -> { resource.association_class.try(:form_class) },
+            object: -> { resource.child_resource },
+            policy: :create?
+          ).merge(overwrite)
+        end
+
+        def create_singular_options(**overwrite)
+          default_create_options(
+            form: -> { resource.class.try(:form_class) },
+            object: -> { resource },
+            policy: :create?
+          ).merge(overwrite)
+        end
+
+        def default_create_options(**overwrite) # rubocop:disable Metrics/MethodLength
+          {
+            action_name: :new,
+            action_path: :new,
+            execute: :create_execute,
+            http_method: :post,
+            image: 'fa-plus',
+            on_failure: :create_failure,
+            on_success: :create_success,
+            result: -> { result_class },
+            target_path: '',
+            type: lambda {
+              [Vocab.ontola["Create::#{result_class}"], Vocab.schema.CreateAction]
+            }
+          }.merge(overwrite)
+        end
+      end
+    end
+  end
+end

data/lib/linked_rails/controller/default_actions/destroy.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module LinkedRails
+  module Controller
+    module DefaultActions
+      module Destroy
+        def has_resource_destroy_action(**overwrite)
+          has_resource_action(:destroy, **destroy_resource_options(**overwrite))
+        end
+
+        def has_singular_destroy_action(**overwrite)
+          has_singular_action(:destroy, **destroy_singular_options(**overwrite))
+        end
+
+        private
+
+        def destroy_resource_options(**overwrite)
+          default_destroy_options(**overwrite)
+        end
+
+        def destroy_singular_options(**overwrite)
+          default_destroy_options(**overwrite)
+        end
+
+        def default_destroy_options(**overwrite) # rubocop:disable Metrics/MethodLength
+          {
+            action_name: :delete,
+            action_path: :delete,
+            execute: :destroy_execute,
+            http_method: :delete,
+            image: 'fa-close',
+            on_failure: :destroy_failure,
+            on_success: :destroy_success,
+            policy: :destroy?,
+            target_path: '',
+            type: [Vocab.schema.Action, Vocab.ontola[:DestroyAction]]
+          }.merge(overwrite)
+        end
+      end
+    end
+  end
+end

data/lib/linked_rails/controller/default_actions/update.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module LinkedRails
+  module Controller
+    module DefaultActions
+      module Update
+        def has_resource_update_action(**overwrite)
+          has_resource_action(:update, **update_resource_options(**overwrite))
+        end
+
+        def has_singular_update_action(**overwrite)
+          has_singular_action(:update, **update_singular_options(**overwrite))
+        end
+
+        private
+
+        def update_resource_options(**overwrite)
+          default_update_options(**overwrite)
+        end
+
+        def update_singular_options(**overwrite)
+          default_update_options(**overwrite)
+        end
+
+        def default_update_options(**overwrite) # rubocop:disable Metrics/MethodLength
+          {
+            action_name: :edit,
+            action_path: :edit,
+            execute: :update_execute,
+            form: -> { resource.class.try(:form_class) },
+            http_method: :put,
+            image: 'fa-pencil-square-o',
+            on_failure: :update_failure,
+            on_success: :update_success,
+            policy: :update?,
+            target_path: '',
+            type: Vocab.schema.UpdateAction
+          }.merge(overwrite)
+        end
+      end
+    end
+  end
+end

data/lib/linked_rails/controller/delta.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module LinkedRails
+  module Controller
+    module Delta
+      include LinkedRails::Helpers::DeltaHelper
+
+      def changes_triples(resource)
+        resource_serializer(resource)&.send(:repository).statements
+      end
+
+      def changed_relations_triples(resource, inverted = nil) # rubocop:disable Metrics/AbcSize
+        resource.previously_changed_relations.flat_map do |key, value|
+          if key.to_s.ends_with?('_collection')
+            changed_collection_triples(resource, key)
+          else
+            destructed = resource.send(:association_has_destructed?, key)
+            records = value.relationship_type == :has_many ? resource.send(key) : [resource.send(key)]
+            changed_relation_triples(value.predicate, destructed, records - [inverted], resource)
+          end
+        end
+      end
+
+      private
+
+      def changed_relation_triples(predicate, destructed, resources, inverted)
+        related_resource_invalidations =
+          resources.flat_map do |resource|
+            resource_delta = invalidate_resource_delta(resource)
+            [resource_delta] + changed_relations_triples(resource, inverted)
+          end
+
+        return related_resource_invalidations unless predicate
+
+        if destructed
+          return related_resource_invalidations + [
+            [current_resource.iri, predicate, Vocab.sp[:Variable], delta_iri(:remove)]
+          ]
+        end
+
+        related_resource_invalidations + resources.map do |resource|
+          [current_resource.iri, predicate, resource.iri, delta_iri(:replace)]
+        end
+      end
+
+      def changed_collection_triples(resource, key)
+        collection = resource.send(key)
+        association = resource.association(collection.association)
+        if association.loaded?
+          [invalidate_collection_delta(collection)] +
+            association.reader.select { |r| r.previous_changes.present? }.flat_map(&method(:changes_triples))
+        else
+          [invalidate_collection_delta(collection)]
+        end
+      end
+    end
+  end
+end

data/lib/linked_rails/controller/error_handling.rb

@@ -7,9 +7,7 @@ module LinkedRails
       include ActiveSupport::Rescuable
 
       included do
-        rescue_from StandardError, with: :handle_and_report_error
-        rescue_from ActiveRecord::RecordNotFound, with: :handle_error
-        rescue_from Pundit::NotAuthorizedError, with: :handle_error
+        rescue_from LinkedRails::Errors::Forbidden, with: :handle_error
       end
 
       private
@@ -22,7 +20,14 @@ module LinkedRails
         !%w[GET HEAD].include?(request.method)
       end
 
+      def handle_and_report_error(error)
+        report_error(error) if error_status(error) == 500
+        handle_error(error)
+      end
+
       def handle_error(error)
+        raise(error) if response_body
+
         respond_to do |format|
           (LinkedRails::Renderers.rdf_content_types + [:json]).each do |type|
             format.send(type) { error_response_serializer(error, type) }
@@ -30,11 +35,10 @@ module LinkedRails
         end
       end
 
-      def handle_and_report_error(error)
-        raise if Rails.env.development? || Rails.env.test?
-        raise if response_body
+      def report_error(error)
+        raise(error) if Rails.env.development? || Rails.env.test?
 
-        handle_error(error)
+        Rails.logger.error(error)
       end
 
       def error_mode(exception)
@@ -69,6 +73,7 @@ module LinkedRails
             'Doorkeeper::Errors::InvalidGrantReuse' => 422,
             'LinkedRails::Auth::Errors::Expired' => 410,
             'LinkedRails::Auth::Errors::Unauthorized' => 401,
+            'LinkedRails::Errors::Forbidden' => 403,
             'Pundit::NotAuthorizedError' => 403
           }
         end

data/lib/linked_rails/controller/rendering.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module LinkedRails
+  module Controller
+    module Rendering
+      def _render_with_renderer_json(record, options)
+        self.content_type = Mime[:json]
+
+        return record if record.is_a?(String)
+        return record.to_json if record.is_a?(Hash)
+
+        serializer_opts = RDF::Serializers::Renderers.transform_opts(
+          options,
+          serializer_params
+        )
+
+        serializer = RDF::Serializers.serializer_for(record)&.new(record, serializer_opts)
+        return record.to_json unless serializer
+
+        Oj.dump(serializer.serializable_hash, mode: :compat)
+      end
+
+      def resource_body(resource)
+        resource_serializer(resource).send(:render_emp_json)
+      end
+
+      def resource_hash(resource)
+        resource_serializer(resource).send(:emp_json_hash)
+      end
+
+      def resource_serializer(resource)
+        return if resource.nil?
+
+        serializer_options = RDF::Serializers::Renderers.transform_opts(
+          {include: resource&.try(:preview_includes)},
+          serializer_params
+        )
+        RDF::Serializers
+          .serializer_for(resource)
+          &.new(resource, serializer_options)
+      end
+
+      def serializer_params
+        {}
+      end
+    end
+  end
+end

data/lib/linked_rails/controller.rb

@@ -1,23 +1,30 @@
 # frozen_string_literal: true
 
 require_relative 'active_response/controller'
+require_relative 'controller/actionable'
 require_relative 'controller/authorization'
 require_relative 'controller/error_handling'
+require_relative 'controller/delta'
+require_relative 'controller/rendering'
 
 module LinkedRails
   module Controller
     extend ActiveSupport::Concern
+    include ::ActiveResponse::Controller
 
     included do
       extend Enhanceable
 
       enhanceable :controller_class, :Controller
 
+      include ActionController::MimeResponds
       include LinkedRails::ActiveResponse::Controller
+      include LinkedRails::Controller::Actionable
       include LinkedRails::Controller::Authorization
       include LinkedRails::Controller::ErrorHandling
+      include LinkedRails::Controller::Rendering
+      include LinkedRails::Controller::Delta
       include LinkedRails::Helpers::OntolaActionsHelper
-      include LinkedRails::Helpers::DeltaHelper
       include LinkedRails::Helpers::ResourceHelper
 
       before_action :set_manifest_header
@@ -34,9 +41,22 @@ module LinkedRails
     end
 
     module ClassMethods
-      def controller_class
-        @controller_class ||=
-          name.sub(/Controller$/, '').classify.safe_constantize || try(:controller_name)&.classify&.safe_constantize
+      def controller_class(klass = nil)
+        if klass.present?
+          @controller_class = klass
+        else
+          @controller_class ||= compute_controller_class || superclass.try(:controller_class)
+        end
+      end
+
+      private
+
+      def compute_controller_class
+        klass =
+          name.sub(/Controller$/, '').classify.safe_constantize ||
+          try(:controller_name)&.classify&.safe_constantize
+
+        klass if klass&.include?(LinkedRails::Model)
       end
     end
   end

data/lib/linked_rails/enhancements/creatable/controller.rb

@@ -7,7 +7,7 @@ module LinkedRails
         extend ActiveSupport::Concern
 
         included do
-          active_response :create
+          has_collection_create_action
         end
       end
     end

data/lib/linked_rails/enhancements/destroyable/controller.rb

@@ -7,7 +7,7 @@ module LinkedRails
         extend ActiveSupport::Concern
 
         included do
-          active_response :destroy
+          has_resource_destroy_action
         end
       end
     end

data/lib/linked_rails/enhancements/updatable/controller.rb

@@ -7,7 +7,7 @@ module LinkedRails
         extend ActiveSupport::Concern
 
         included do
-          active_response :update
+          has_resource_update_action
         end
       end
     end

data/lib/linked_rails/enhancements.rb

@@ -1,22 +1,6 @@
 # frozen_string_literal: true
 
-require_relative 'enhancements/route_concerns'
-
-require_relative 'enhancements/actionable/model'
-require_relative 'enhancements/actionable/serializer'
-require_relative 'enhancements/creatable/action'
 require_relative 'enhancements/creatable/controller'
-require_relative 'enhancements/destroyable/action'
 require_relative 'enhancements/destroyable/controller'
-require_relative 'enhancements/destroyable/routing'
-require_relative 'enhancements/indexable/model'
-require_relative 'enhancements/menuable/model'
-require_relative 'enhancements/menuable/serializer'
-require_relative 'enhancements/singularable/controller'
-require_relative 'enhancements/singularable/model'
-require_relative 'enhancements/singularable/serializer'
-require_relative 'enhancements/tableable/model'
-require_relative 'enhancements/updatable/action'
 require_relative 'enhancements/updatable/controller'
-require_relative 'enhancements/updatable/routing'
 require_relative 'enhancements/updatable/serializer'

data/lib/linked_rails/errors/forbidden.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module LinkedRails
+  module Errors
+    class Forbidden < StandardError
+      attr_reader :query, :record, :policy, :action
+
+      # @param [Hash] options
+      # @option options [String] query The action of the request
+      # @option options [ActiveRecord::Base] record The record that was requested
+      # @option options [Policy] policy The policy that raised the exception
+      # @option options [String] message Override the default error message
+      # @return [String] the message
+      def initialize(**options)
+        @query  = options.fetch(:query).to_s
+        @record = options[:record]
+        @policy = options[:policy]
+        @action = @query[-1] == '?' ? @query[0..-2] : @query
+        @message = options[:message]
+
+        raise StandardError if @query.blank? && @message.blank?
+
+        super(@message || default_message)
+      end
+
+      private
+
+      def default_message
+        I18n.t(
+          "pundit.#{@policy.class.to_s.underscore}.#{@query}",
+          action: @action,
+          default: I18n.t('errors.access_denied')
+        )
+      end
+    end
+  end
+end

data/lib/linked_rails/errors.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require_relative 'errors/forbidden'