linked_rails 0.0.3 → 0.0.4

data/lib/generators/linked_rails/model/templates/policy.rb.tt

@@ -2,5 +2,18 @@
 
 <% module_namespacing do -%>
 class <%= class_name %>Policy < ApplicationPolicy
+  permit_attributes %i[<%= attributes.map { |attribute| attribute.name }.join(' ') %>]
+
+  def create?
+    false
+  end
+
+  def update?
+    false
+  end
+
+  def destroy?
+    false
+  end
 end
 <% end -%>

data/lib/generators/linked_rails/model/templates/serializer.rb.tt

@@ -3,7 +3,7 @@
 <% module_namespacing do -%>
 class <%= class_name %>Serializer < ApplicationSerializer
 <% attributes.each do |attribute| -%>
-    attribute :<%= attribute.name %>, predicate: LinkedRails.app_vocab[:<%= attribute.name %>]
+  attribute :<%= attribute.name %>, predicate: Vocab.app[:<%= attribute.name %>]
 <% end -%>
 end
 <% end -%>

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!.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

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

@@ -11,13 +11,11 @@ module LinkedRails
         end
 
         def params_parser
-          @params_parser ||= LinkedRails::ParamsParser.new(params)
+          @params_parser ||= LinkedRails::ParamsParser.new(params: params, user_context: user_context)
         end
 
         def parsed_filter_params
-          filters = params_parser.filter_params
-
-          ActionController::Parameters.new(controller_class.try(:attributes_from_filters, filters) || {})
+          params_parser.attributes_from_filters(controller_class)
         end
 
         def permit_filter_params
@@ -37,7 +35,9 @@ 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

data/lib/linked_rails/active_response/controller.rb

@@ -33,5 +33,16 @@ module LinkedRails
     def serializer_params
       {}
     end
+
+    def success_message_translation_key
+      "actions.#{Translate.translation_key(controller_class)}.#{action_name}.success"
+    end
+
+    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, :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,118 @@
+# 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
+        # @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
+        # @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 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 [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.build_child },
+            policy: :create_child?
+          ).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.rb

@@ -1,19 +1,23 @@
 # frozen_string_literal: true
 
 require_relative 'active_response/controller'
+require_relative 'controller/actionable'
 require_relative 'controller/authorization'
 require_relative 'controller/error_handling'
 
 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::Helpers::OntolaActionsHelper
@@ -34,9 +38,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'