linked_rails 0.0.1 → 0.0.4.pre.g2c53724b3

data/lib/linked_rails/active_response/controller/collections.rb

@@ -9,7 +9,7 @@ module LinkedRails
         def index_association; end
 
         def index_includes
-          requested_resource.preview_includes
+          requested_resource!.try(:preview_includes)
         end
 
         def index_iri

data/lib/linked_rails/active_response/controller/crud_defaults.rb

@@ -10,8 +10,8 @@ module LinkedRails
           current_resource!
             .class
             .try(:reflect_on_all_associations)
-            .select(&:collection?)
-            .each { |association| current_resource!.association(association.name).reset }
+            &.select(&:collection?)
+            &.each { |association| current_resource!.association(association.name).reset }
         end
 
         def create_execute
@@ -50,7 +50,7 @@ module LinkedRails
         def requested_resource
           @requested_resource ||= controller_class.try(
             :requested_resource,
-            LinkedRails.iri_mapper.route_params_to_opts(params.dup),
+            LinkedRails.iri_mapper.route_params_to_opts(params.dup, request.original_url),
             user_context
           )
         end
@@ -80,7 +80,7 @@ module LinkedRails
         end
 
         def update_meta
-          changes_triples + changed_relations_triples
+          changes_triples(current_resource) + changed_relations_triples(current_resource)
         end
 
         def user_context

data/lib/linked_rails/active_response/controller/params.rb

@@ -11,17 +11,13 @@ module LinkedRails
         end
 
         def params_parser
-          @params_parser ||= LinkedRails::ParamsParser.new(params)
-        end
-
-        def parsed_filter_params
-          filters = params_parser.filter_params
-
-          ActionController::Parameters.new(controller_class.try(:attributes_from_filters, filters) || {})
+          @params_parser ||= LinkedRails::ParamsParser.new(params: params, user_context: user_context)
         end
 
         def permit_filter_params
-          @permit_filter_params ||= parsed_filter_params.permit(*permit_param_keys)
+          @permit_filter_params ||=
+            policy(requested_resource || new_resource)
+              .permitted_attributes_from_filters(params_parser.filter_params)
         end
 
         def permit_params
@@ -37,11 +33,15 @@ module LinkedRails
         end
 
         def permit_params_with_filters
-          permit_filter_params.merge(permit_params.to_h)
+          permitted = permit_filter_params.merge(permit_params.to_h)
+          permitted[:singular_resource] = true if params[:singular_route].to_s == 'true'
+          permitted
         end
 
         def resource_params
-          return ActionController::Parameters.new if !params.key?(permit_param_key) && allow_empty_params?
+          empty_params = !params.key?(permit_param_key) || params[permit_param_key] == {}
+
+          return ActionController::Parameters.new if empty_params && allow_empty_params?
 
           params.require(permit_param_key)
         end

data/lib/linked_rails/active_response/controller.rb

@@ -8,30 +8,20 @@ require_relative 'controller/params'
 
 module LinkedRails
   module Controller
-    include Pundit
+    include Pundit::Authorization
     include LinkedRails::ActiveResponse::Controller::Collections
     include LinkedRails::ActiveResponse::Controller::CrudDefaults
     include LinkedRails::ActiveResponse::Controller::Params
 
-    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)
+    def success_message_translation_key
+      "actions.#{Translate.translation_key(controller_class)}.#{action_name}.success"
     end
 
-    def serializer_params
-      {}
+    def success_message_translation_opts
+      {
+        default: [:"actions.default.#{action_name}.success", ''],
+        type: I18n.t("#{controller_class.model_name.collection}.type").capitalize
+      }
     end
   end
 end

data/lib/linked_rails/active_response/responders/rdf.rb

@@ -37,7 +37,7 @@ module LinkedRails
           response_headers(opts)
           controller.respond_with_resource(
             resource: nil,
-            meta: error_meta(opts[:resource]),
+            meta: error_meta(opts[:resource], opts[:errors] || {}),
             status: :unprocessable_entity
           )
         end
@@ -47,15 +47,22 @@ module LinkedRails
           controller.respond_with_resource(opts)
         end
 
-        def redirect(**opts) # rubocop:disable Metrics/AbcSize
+        def redirect(**opts) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
           return super if controller.request.head?
 
+          opts[:status] ||= 200
+
           response_headers(opts)
           add_exec_action_header(
             controller.response.headers,
             ontola_redirect_action(opts[:location], reload: opts[:reload])
           )
-          controller.head 200, content_type: content_type, location: opts[:location]
+          if opts[:meta].blank? || head_request?
+            controller.head(opts[:status], location: opts[:location], content_type: content_type)
+          else
+            opts[format] = []
+            controller.render opts
+          end
         end
 
         def resource(**opts) # rubocop:disable Metrics/AbcSize
@@ -89,10 +96,10 @@ module LinkedRails
           ]
         end
 
-        def error_statements(iri, resource)
+        def error_statements(iri, resource, resource_errors)
           index = 0
-          resource.errors.messages.map do |key, values|
-            predicate = resource.class.predicate_for_key(key.to_s.split('.').first)
+          resource_errors.map do |key, values|
+            predicate = resource&.class&.predicate_for_key(key.to_s.split('.').first)
             if predicate
               error_statements_for(iri, predicate, values)
             else
@@ -106,16 +113,18 @@ module LinkedRails
           values.map { |value| [iri, predicate, value.sub(/\S/, &:upcase)] }
         end
 
-        def error_meta(resource)
+        def error_meta(resource, custom_errors)
           form_iri = controller.request.headers['Request-Referrer']
-          return [] unless form_iri && resource.respond_to?(:errors)
+          resource_errors = (resource.try(:errors)&.messages || {}).merge(custom_errors)
+
+          return [] unless form_iri && resource_errors.present?
 
           error_object = ::RDF::Node.new
           [
             error_mapping(form_iri, error_object),
             error_type(error_object),
             error_status(error_object)
-          ] + error_statements(error_object, resource)
+          ] + error_statements(error_object, resource, resource_errors)
         end
 
         def error_type(error_object)
@@ -149,7 +158,7 @@ module LinkedRails
           error_statements_for(
             iri,
             ::RDF["_#{index}"],
-            values.map { |value| resource.errors.full_message(key, value) }
+            values.map { |value| resource&.errors&.full_message(key, value) || value }
           )
         end
       end

data/lib/linked_rails/callable_variable.rb

@@ -5,7 +5,7 @@ module LinkedRails
     extend ActiveSupport::Concern
 
     module ClassMethods
-      def callable_variable(method, opts = {}) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+      def callable_variable(method, **opts) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
         variable ||= opts[:variable] || method
         default ||= opts[:default]
 

data/lib/linked_rails/collection_params_parser.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+module LinkedRails
+  class CollectionParamsParser
+    attr_reader :params, :user_context
+
+    def initialize(params)
+      @user_context = params[:user_context]
+      @params = params.is_a?(Hash) ? ActionController::Parameters.new(params) : params
+    end
+
+    def collection_params
+      return @collection_params if instance_variable_defined?(:@collection_params)
+
+      values = permit_params(:display, :page_size, :table_type, :title, :type)
+
+      filter = filter_params
+      values[:filter] = filter if filter
+
+      sort = sorting_params
+      values[:sort] = sort if sort
+
+      values[:user_context] = user_context if user_context
+
+      @collection_params = values
+    end
+
+    def collection_view_params
+      return @collection_view_params if instance_variable_defined?(:@collection_view_params)
+
+      values = permit_params(:page)
+
+      before = before_params
+      values[:before] = before if before
+
+      @collection_view_params = values
+    end
+
+    def filter_params # rubocop:disable Metrics/AbcSize
+      return @filter_params if instance_variable_defined?(:@filter_params)
+
+      values = permit_params(filter: [])[:filter] || permit_params(filter: {})[:filter]
+      return @filter_params = values if values.is_a?(Hash)
+      return @filter_params = {} if values.blank?
+
+      @filter_params = values.each_with_object({}) do |f, hash|
+        values = f.split('=')
+        key = RDF::URI(CGI.unescape(values.first))
+        hash[key] ||= []
+        hash[key] << CGI.unescape(values.second)
+      end
+    end
+
+    private
+
+    def before_params
+      return @before_params if instance_variable_defined?(:@before_params)
+
+      values = permit_params(before: [])[:before]
+      return @before_params = nil if values.blank?
+
+      @before_params = values.map do |f|
+        key, value = f.split('=')
+        {key: RDF::URI(CGI.unescape(key)), value: value}
+      end
+    end
+
+    def parse_filter_value(value)
+      return value if value.is_a?(Hash)
+
+      key, value = value.split('=')
+      {key: RDF::URI(CGI.unescape(key)), direction: value}
+    end
+
+    def permit_params(*keys)
+      params
+        .permit(*keys)
+        .to_h
+        .with_indifferent_access
+    end
+
+    def sorting_params
+      return @sorting_params if instance_variable_defined?(:@sorting_params)
+
+      values = permit_params(sort: [])[:sort]
+      return @sorting_params = nil if values.blank?
+
+      @sorting_params = values.map do |f|
+        parse_filter_value(f)
+      end
+    end
+  end
+end

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

@@ -4,11 +4,7 @@ module LinkedRails
   module Controller
     module ErrorHandling
       extend ActiveSupport::Concern
-      included do
-        rescue_from StandardError, with: :handle_and_report_error
-        rescue_from ActiveRecord::RecordNotFound, with: :handle_error
-        rescue_from Pundit::NotAuthorizedError, with: :handle_error
-      end
+      include ActiveSupport::Rescuable
 
       private
 
@@ -20,7 +16,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) }
@@ -28,11 +31,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)