linked_rails 0.0.4.pre.gfe77aae19 → 0.0.4

data/lib/linked_rails/controller/error_handling.rb

@@ -7,7 +7,9 @@ module LinkedRails
       include ActiveSupport::Rescuable
 
       included do
-        rescue_from LinkedRails::Errors::Forbidden, with: :handle_error
+        rescue_from StandardError, with: :handle_and_report_error
+        rescue_from ActiveRecord::RecordNotFound, with: :handle_error
+        rescue_from Pundit::NotAuthorizedError, with: :handle_error
       end
 
       private
@@ -20,14 +22,7 @@ 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) }
@@ -35,10 +30,11 @@ module LinkedRails
         end
       end
 
-      def report_error(error)
-        raise(error) if Rails.env.development? || Rails.env.test?
+      def handle_and_report_error(error)
+        raise if Rails.env.development? || Rails.env.test?
+        raise if response_body
 
-        Rails.logger.error(error)
+        handle_error(error)
       end
 
       def error_mode(exception)
@@ -73,7 +69,6 @@ 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.rb

@@ -4,8 +4,6 @@ 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
@@ -22,9 +20,8 @@ module LinkedRails
       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

data/lib/linked_rails/helpers/delta_helper.rb

@@ -3,8 +3,64 @@
 module LinkedRails
   module Helpers
     module DeltaHelper
+      def changed_relation_triples(predicate, destructed, resources)
+        related_resource_invalidations = resources.map(&method(:invalidate_resource_delta))
+
+        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_relations_triples # rubocop:disable Metrics/AbcSize
+        current_resource.previously_changed_relations.flat_map do |key, value|
+          if key.to_s.ends_with?('_collection')
+            [invalidate_collection_delta(current_resource.send(key))]
+          else
+            destructed = current_resource.send(:association_has_destructed?, key)
+            many = value.relationship_type == :has_many
+            relation = current_resource.send(key)
+            changed_relation_triples(value.predicate, destructed, many ? relation : [relation])
+          end
+        end
+      end
+
+      def change_triple(predicate, value)
+        if value.nil?
+          RDF::Statement.new(current_resource.iri, predicate, Vocab.sp[:Variable], graph_name: delta_iri(:remove))
+        else
+          RDF::Statement.new(current_resource.iri, predicate, value, graph_name: delta_iri(:replace))
+        end
+      end
+
+      def changes_triples # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+        serializer_class = RDF::Serializers.serializer_for(current_resource)
+        return [] if serializer_class.blank?
+
+        serializer = serializer_class.new(current_resource)
+
+        current_resource.previous_changes_by_predicate.map do |predicate, (_old_value, _new_value)|
+          serializer_attributes = current_resource.class.predicate_mapping[predicate]
+          next if serializer_attributes.is_a?(FastJsonapi::Relationship)
+
+          attr_name = serializer_attributes.key
+          serialized_value =
+            serializer.class.attributes_to_serialize[attr_name]&.serialize(current_resource, serializer_params, {})
+          (serialized_value.is_a?(Array) ? serialized_value : [serialized_value]).map do |value|
+            change_triple(predicate, value)
+          end
+        end.compact.flatten
+      end
+
       def delta_iri(delta)
-        %i[remove replace invalidate].include?(delta) ? Vocab.ontola[delta] : Vocab.ld[delta]
+        %i[remove replace invalidate].include?(delta) ? Vocab.ontola[delta] : Vocab.ll[delta]
       end
 
       def invalidate_collection_delta(collection)
@@ -12,9 +68,7 @@ module LinkedRails
       end
 
       def invalidate_parent_collections_delta(resource)
-        context = user_context if respond_to?(:user_context, true)
-
-        resource&.parent_collections(context)&.map(&method(:invalidate_collection_delta)) || []
+        resource&.parent_collections(try(:user_context))&.map(&method(:invalidate_collection_delta)) || []
       end
 
       def invalidate_resource_delta(resource)

data/lib/linked_rails/helpers/resource_helper.rb

@@ -41,28 +41,16 @@ module LinkedRails
       end
 
       def requested_resource_parent
-        requested_resource.try(:parent)
+        requested_resource&.parent
       end
 
       private
 
-      def request_path_to_url(path)
-        return path unless path.present? && URI(path).relative?
-
-        port = [80, 443].include?(request.port) ? nil : request.port
-        URI::Generic.new(request.scheme, nil, request.host, port, nil, path, nil, nil, nil).to_s
-      end
-
       def build_new_resource
         controller_class.build_new(user_context: user_context)
       end
 
       def new_resource_from_parent
-        if requested_resource.is_a?(LinkedRails.collection_class) ||
-          requested_resource.is_a?(LinkedRails.collection_view_class)
-          return requested_resource.child_resource
-        end
-
         parent_resource.build_child(
           controller_class,
           user_context: user_context

data/lib/linked_rails/iri_mapper.rb

@@ -38,7 +38,7 @@ module LinkedRails
         params = Rails.application.routes.recognize_path(iri.to_s, method: method)
 
         route_params_to_opts(params.merge(query), iri.to_s)
-      rescue ActionController::RoutingError, SystemStackError
+      rescue ActionController::RoutingError
         EMPTY_IRI_OPTS.dup
       end
 

data/lib/linked_rails/middleware/linked_data_params.rb

@@ -1,13 +1,8 @@
 # frozen_string_literal: true
 
-# require 'empathy/emp_json'
-
 module LinkedRails
   module Middleware
     class LinkedDataParams
-      include ::Empathy::EmpJson::Helpers::Slices
-      include ::Empathy::EmpJson::Helpers::Parsing
-
       def initialize(app)
         @app = app
       end
@@ -15,7 +10,7 @@ module LinkedRails
       def call(env)
         req = Rack::Request.new(env)
         params_from_query(req)
-        params_from_slice(req)
+        params_from_graph(req)
 
         @app.call(env)
       end
@@ -36,32 +31,38 @@ module LinkedRails
         request.update_param(class_key, data) if data.present?
       end
 
-      def slice_from_request(request)
-        return unless request.content_type == Mime::Type.lookup_by_extension(:empjson).to_s
-
-        body = request.body.read
+      def graph_from_request(request)
+        request_graph = request.delete_param("<#{Vocab.ll[:graph].value}>")
+        return if request_graph.blank?
 
-        JSON.parse(body) if body.present?
+        RDF::Graph.load(
+          request_graph[:tempfile].path,
+          content_type: request_graph[:type],
+          canonicalize: true,
+          intern: false
+        )
       end
 
-      # Converts a emp slice from to a nested attributes hash.
+      # Converts a serialized graph from a multipart request body to a nested
+      # attributes hash.
       #
-      # The entrypoint for the slice is the `.` subject, which is
+      # The graph sent to the server should be sent under the `ll:graph` form name.
+      # The entrypoint for the graph is the `ll:targetResource` subject, which is
       # assumed to be the resource intended to be targeted by the request (i.e. the
       # resource to be created, updated, or deleted).
       #
       # @return [Hash] A hash of attributes, empty if no statements were given.
-      def params_from_slice(request)
-        slice = slice_from_request(request)
+      def params_from_graph(request)
+        graph = graph_from_request(request)
 
-        return unless slice
+        return unless graph
 
-        request.env['emp_json'] = slice
+        request.update_param(:body_graph, graph)
         target_class = target_class_from_path(request)
         return if target_class.blank?
 
-        update_actor_param(request, slice)
-        update_target_params(request, slice, target_class)
+        update_actor_param(request, graph)
+        update_target_params(request, graph, target_class)
       end
 
       def params_from_query(request)
@@ -82,19 +83,19 @@ module LinkedRails
         opts[:class]
       end
 
-      def update_actor_param(request, slice)
-        actor = values_from_slice(slice, '.', Vocab.schema.creator)
-
+      def update_actor_param(request, graph)
+        actor = graph.query([Vocab.ll[:targetResource], Vocab.schema.creator]).first
         return if actor.blank?
 
-        request.update_param(:actor_iri, emp_to_primitive(actor))
+        request.update_param(:actor_iri, actor.object)
+        graph.delete(actor)
       end
 
-      def update_target_params(request, slice, target_class)
+      def update_target_params(request, graph, target_class)
         key = target_class.to_s.demodulize.underscore
 
-        parser = ParamsParser.new(slice: slice, params: request.params)
-        from_body = parser.parse_resource('.', target_class)
+        parser = ParamsParser.new(graph: graph, params: request.params)
+        from_body = parser.parse_resource(Vocab.ll[:targetResource], target_class)
 
         request.update_param(key, from_body.merge(request.params[key] || {}))
       end

data/lib/linked_rails/model/actionable.rb

@@ -45,7 +45,9 @@ module LinkedRails
 
       module ClassMethods
         def action_list
-          @action_list ||= define_action_list
+          return @action_list if @action_list.try(:actionable_class) == self
+
+          @action_list = defined_action_list || define_action_list
         end
 
         private
@@ -54,13 +56,12 @@ module LinkedRails
           superclass.try(:action_list) || LinkedRails.action_list_parent_class
         end
 
+        def defined_action_list
+          'ActionList'.safe_constantize
+        end
+
         def define_action_list
-          klass = Class.new(action_superclass)
-          actionable_class = self
-          klass.define_singleton_method(:actionable_class) do
-            actionable_class
-          end
-          klass
+          const_set('ActionList', Class.new(action_superclass))
         end
       end
     end

data/lib/linked_rails/model/collections.rb

@@ -37,8 +37,6 @@ module LinkedRails
         association_class: nil,
         # association_scope [Sym] The scope applied to the collection.
         association_scope: nil,
-        # call_to_action [String] The label shown as call to action.
-        call_to_action: nil,
         # collection_class [Class] The base class of the collection.
         #   If you want to use a class other than LinkedRails.collection_class.
         collection_class: nil,
@@ -46,8 +44,6 @@ module LinkedRails
         default_filters: {},
         # collection_class [Array<Hash>] The default sortings applied to the collection.
         default_sortings: [{key: Vocab.schema.dateCreated, direction: :desc}],
-        # include_members [Boolean] Whether to include the members of this collection.
-        include_members: false,
         # iri_template_keys [Array<Sym>] Custom query keys for the iri template
         iri_template_keys: [],
         # joins [Array<Sym>, Sym] The associations to join
@@ -62,9 +58,7 @@ module LinkedRails
         #   Set to false to skip scoping
         policy_scope: -> { policy ? policy::Scope : Pundit::PolicyFinder.new(filtered_association).scope! },
         # route_key [Symbol, String] The route key for the association
-        route_key: nil,
-        # view [IRI] The view to use for rendering the members
-        view: nil
+        route_key: nil
       }.freeze
       COLLECTION_OPTIONS = COLLECTION_CUSTOMIZABLE_OPTIONS.merge(COLLECTION_STATIC_OPTIONS)
 
@@ -85,7 +79,7 @@ module LinkedRails
 
             _default_collection_opts[key] = value
           end
-          _default_collection_opts[:iri_template] = _default_collection_opts[:collection_class].generate_iri_template(
+          _default_collection_opts[:iri_template] = LinkedRails.collection_class.generate_iri_template(
             _default_collection_opts[:iri_template_keys]
           )
           _default_collection_opts
@@ -121,7 +115,7 @@ module LinkedRails
           options[:association] ||= name.to_sym
           options[:association_class] ||= name.to_s.classify.constantize
           merged_options = options[:association_class].default_collection_options.merge(options)
-          merged_options[:iri_template] = merged_options[:collection_class].generate_iri_template(
+          merged_options[:iri_template] = LinkedRails.collection_class.generate_iri_template(
             merged_options[:iri_template_keys]
           )
           collections_add(name: name, options: merged_options)
@@ -153,7 +147,7 @@ module LinkedRails
 
           _default_collection_opts[:collection_class] ||= LinkedRails.collection_class
           _default_collection_opts[:association_class] = self
-          _default_collection_opts[:iri_template] = _default_collection_opts[:collection_class].generate_iri_template(
+          _default_collection_opts[:iri_template] = LinkedRails.collection_class.generate_iri_template(
             _default_collection_opts[:iri_template_keys]
           )
 

data/lib/linked_rails/model/dirty.rb

@@ -22,28 +22,40 @@ module LinkedRails
         end
       end
 
-      def previously_changed_relations(inverted = nil)
+      def previous_changes_by_predicate
+        serializer_class = RDF::Serializers.serializer_for(self)
+        return {} unless respond_to?(:previous_changes) && serializer_class
+
+        Hash[
+          previous_changes
+            .map { |k, v| [self.class.predicate_for_key(k.to_sym), v] }
+            .select { |k, _v| k.present? }
+        ]
+      end
+
+      def previously_changed_relations
         serializer_class = RDF::Serializers.serializer_for(self)
         return {} unless serializer_class.try(:relationships_to_serialize)
 
         serializer_class.relationships_to_serialize.select do |key, _value|
           if respond_to?(key)
             association_key = key.to_s.ends_with?('_collection') ? send(key).association : key
-            association_has_destructed?(association_key) || association_changed?(association_key, inverted)
+            association_has_destructed?(association_key) || association_changed?(association_key)
           end
         end.with_indifferent_access
       end
 
       private
 
-      def association_changed?(association, inverted) # rubocop:disable Metrics/AbcSize
+      def association_changed?(association) # rubocop:disable Metrics/AbcSize
         ids_method = "#{association.to_s.singularize}_ids"
         return true if previous_changes.include?("#{association}_id") || previous_changes.include?(ids_method)
         return false unless try(:association_cached?, association)
-        records = self.class.reflect_on_association(association).collection? ? send(association) : [send(association)]
 
-        records.reject { |a| a == inverted }.any? do |a|
-          a&.previous_changes.present? || a&.previously_changed_relations(self).present?
+        if self.class.reflect_on_association(association).collection?
+          send(association).any? { |a| a.previous_changes.present? }
+        else
+          send(association)&.previous_changes&.present?
         end
       end
 

data/lib/linked_rails/model/filtering.rb

@@ -17,7 +17,7 @@ module LinkedRails
         def filterable(**options)
           initialize_filter_options
 
-          self.filter_options = filter_options.merge(options)
+          self.filter_options = HashWithIndifferentAccess.new(options).merge(filter_options)
 
           options.map { |k, filter| define_filter_method(k, filter) }
         end
@@ -34,7 +34,7 @@ module LinkedRails
         def initialize_filter_options
           return if filter_options && method(:filter_options).owner == singleton_class
 
-          self.filter_options = superclass.try(:filter_options)&.dup || HashWithIndifferentAccess.new
+          self.filter_options = superclass.try(:filter_options)&.dup || {}
         end
 
         def define_filter_method(key, filter)

data/lib/linked_rails/model/indexable.rb

@@ -27,7 +27,7 @@ module LinkedRails
         private
 
         def collection_from_parent_name(parent, _params)
-          collection_name = "#{name.demodulize.underscore}_collection"
+          collection_name = "#{name.underscore}_collection"
 
           collection_name if parent.respond_to?(collection_name, true)
         end

data/lib/linked_rails/model/iri.rb

@@ -2,7 +2,7 @@
 
 module LinkedRails
   module Model
-    module IRI
+    module Iri
       extend ActiveSupport::Concern
 
       def anonymous_iri
@@ -62,7 +62,6 @@ module LinkedRails
         iri = root_relative_iri.dup
         iri.scheme = LinkedRails.scheme
         iri.host = LinkedRails.host
-        iri.path = iri.path.presence || '/'
         iri
       end
 
@@ -109,22 +108,11 @@ module LinkedRails
           @iri_template ||= LinkedRails::URITemplate.new("/#{route_key}{/id}{#fragment}")
         end
 
-        def iris_from_scope(scope)
-          ids = ids_for_iris(scope).uniq
-          ids.map { |id| LinkedRails.iri(path: iri_template.expand(id: id)) }
-        end
-
-        def ids_for_iris(scope)
-          scope.pluck(:id)
-        end
-
         def linked_rails_module?
           (Rails.version < '6' ? parents : module_parents).include?(LinkedRails)
         end
 
-        def route_key
-          try(:model_name)&.route_key || to_s.tableize
-        end
+        delegate :route_key, to: :model_name
       end
     end
   end

data/lib/linked_rails/model/iri_mapping.rb

@@ -2,7 +2,7 @@
 
 module LinkedRails
   module Model
-    module IRIMapping
+    module IriMapping
       extend ActiveSupport::Concern
 
       module ClassMethods
@@ -51,7 +51,7 @@ module LinkedRails
           if self < ActiveRecord::Base
             find_by(primary_key => params[:id]) if params.key?(:id)
           else
-            new(params.except(:format))
+            new(params)
           end
         end
 
@@ -85,7 +85,7 @@ module LinkedRails
 
         def iri_without_action(url)
           iri = RDF::URI(url)
-          iri.path = iri.path.split('/')[0...-1].join('/') if iri.path
+          iri.path = iri.path.split('/')[0...-1].join('/')
           iri.to_s
         end
 

data/lib/linked_rails/model/menuable.rb

@@ -14,7 +14,7 @@ module LinkedRails
       end
 
       def menu_list(user_context = nil)
-        @menu_list ||= {}
+        @menu_list = {}
         @menu_list[user_context] ||= self.class.menu_class.new(resource: self, user_context: user_context)
       end
 
@@ -22,6 +22,12 @@ module LinkedRails
         def menu_class
           @menu_class ||= "#{name}MenuList".safe_constantize || "#{superclass.name}MenuList".safe_constantize
         end
+
+        def preview_includes
+          return super if menu_class.blank?
+
+          super + menu_class.defined_menus.keys.map { |tag| "#{tag}_menu" }
+        end
       end
     end
   end

data/lib/linked_rails/model/serialization.rb

@@ -16,6 +16,10 @@ module LinkedRails
       end
 
       module ClassMethods
+        def include_in_collection?
+          false
+        end
+
         def input_select_property
           Vocab.schema.name
         end
@@ -55,7 +59,7 @@ module LinkedRails
           serializer
             .attributes_to_serialize
             .values
-            .select { |attr| attr.predicate.present? && !attr.predicate.is_a?(Proc) }
+            .select { |attr| attr.predicate.present? }
             .map { |attr| [attr.predicate, attr] }
         end
 
@@ -66,7 +70,7 @@ module LinkedRails
           serializer
             .relationships_to_serialize
             .values
-            .select { |value| value.predicate.present? && !value.predicate.is_a?(Proc) }
+            .select { |value| value.predicate.present? }
             .map { |value| [value.predicate, value] }
         end
       end

data/lib/linked_rails/model/singularable.rb

@@ -14,7 +14,7 @@ module LinkedRails
       end
 
       def root_relative_iri(**opts)
-        return super unless singular_iri?
+        return super unless anonymous_iri?
 
         root_relative_singular_iri(**opts)
       end
@@ -25,10 +25,6 @@ module LinkedRails
         @singular_iri ||= iri_with_root(root_relative_singular_iri)
       end
 
-      def singular_iri?
-        anonymous_iri?
-      end
-
       def singular_iri_opts
         {}
       end
@@ -42,8 +38,6 @@ module LinkedRails
       end
 
       class_methods do
-        delegate :singular_route_key, to: :model_name
-
         def requested_singular_resource(_params, _user_context)
           raise(NotImplementedError)
         end
@@ -51,6 +45,10 @@ module LinkedRails
         def singular_iri_template
           @singular_iri_template ||= LinkedRails::URITemplate.new("{/parent_iri*}/#{singular_route_key}{#fragment}")
         end
+
+        def singular_route_key
+          name.underscore
+        end
       end
     end
   end

data/lib/linked_rails/model/tables.rb

@@ -18,7 +18,7 @@ module LinkedRails
         def initialize_columns
           return if defined_columns && method(:defined_columns).owner == singleton_class
 
-          self.defined_columns = superclass.try(:defined_columns)&.dup || {}.with_indifferent_access
+          self.defined_columns = superclass.try(:defined_columns)&.dup || {}
         end
       end
     end

data/lib/linked_rails/model.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require_relative 'model/actionable'
-require_relative 'model/cacheable'
 require_relative 'model/collections'
 require_relative 'model/dirty'
 require_relative 'model/enhancements'
@@ -24,8 +23,8 @@ module LinkedRails
     include Enhancements
     include Filtering
     include Indexable
-    include IRI
-    include IRIMapping
+    include Iri
+    include IriMapping
     include Menuable
     include Serialization
     include Singularable
@@ -38,8 +37,6 @@ module LinkedRails
 
     module ClassMethods
       def build_new(parent: nil, user_context: nil)
-        raise(ActiveRecord::RecordNotFound) if try(:abstract_class?)
-
         new(**attributes_for_new(parent: parent, user_context: user_context))
       end