linked_rails 0.0.3 → 0.0.4.pre.g0ec6e30ca

data/lib/linked_rails/helpers/delta_helper.rb

@@ -3,83 +3,54 @@
 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
+      def delta_iri(delta)
+        %i[remove replace invalidate].include?(delta) ? Vocab.ontola[delta] : Vocab.ld[delta]
+      end
 
-        if destructed
-          return related_resource_invalidations + [
-            [current_resource.iri, predicate, Vocab.sp[:Variable], delta_iri(:remove)]
-          ]
-        end
+      def invalidate_collection_delta(collection)
+        iri = collection.is_a?(RDF::Resource) ? collection : collection.iri
 
-        related_resource_invalidations + resources.map do |resource|
-          [current_resource.iri, predicate, resource.iri, delta_iri(:replace)]
-        end
+        [Vocab.sp[:Variable], Vocab.ontola[:baseCollection], iri, delta_iri(:invalidate)]
       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 invalidate_parent_collections_delta(resource)
+        context = user_context if respond_to?(:user_context, true)
 
-      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
+        resource&.parent_collections(context)&.map(&method(:invalidate_collection_delta)) || []
       end
 
-      def changes_triples # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
-        serializer = RDF::Serializers.serializer_for(current_resource).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)
+      def invalidate_resource_delta(resource)
+        iri = resource.is_a?(RDF::Resource) ? resource : resource.iri
 
-          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
+        [iri, Vocab.sp[:Variable], Vocab.sp[:Variable], delta_iri(:invalidate)]
       end
 
-      def delta_iri(delta)
-        %i[remove replace invalidate].include?(delta) ? Vocab.ontola[delta] : Vocab.ll[delta]
+      def resource_added_delta(resource)
+        invalidate_parent_collections_delta(resource) + singular_added_delta(resource)
       end
 
-      def invalidate_collection_delta(collection)
-        [Vocab.sp[:Variable], Vocab.ontola[:baseCollection], collection.iri, delta_iri(:invalidate)]
+      def resource_removed_delta(resource)
+        invalidate_parent_collections_delta(resource) + singular_removed_delta(resource)
       end
 
-      def invalidate_parent_collections_delta(resource)
-        resource&.parent_collections(try(:user_context))&.map(&method(:invalidate_collection_delta)) || []
+      def same_as_statement(from, to)
+        [
+          from,
+          Vocab.owl.sameAs,
+          to
+        ]
       end
 
-      def invalidate_resource_delta(resource)
-        iri = resource.is_a?(RDF::Resource) ? resource : resource.iri
+      def singular_added_delta(resource)
+        return [] unless resource.try(:singular_resource?)
 
-        [iri, Vocab.sp[:Variable], Vocab.sp[:Variable], delta_iri(:invalidate)]
+        [same_as_statement(resource.singular_iri, resource.iri)]
       end
 
-      def resource_added_delta(resource)
-        invalidate_parent_collections_delta(resource)
-      end
+      def singular_removed_delta(resource)
+        return [] unless resource.try(:singular_resource?)
 
-      def resource_removed_delta(resource)
-        invalidate_parent_collections_delta(resource)
+        [invalidate_resource_delta(resource.singular_iri)]
       end
     end
   end

data/lib/linked_rails/helpers/ontola_actions_helper.rb

@@ -12,8 +12,8 @@ module LinkedRails
         Vocab.libro["actions/copyToClipboard?#{{value: value}.to_param}"]
       end
 
-      def ontola_dialog_action(resource, opener: nil)
-        Vocab.libro["actions/dialog/alert?#{{resource: resource, opener: opener}.compact.to_param}"]
+      def ontola_dialog_action(resource, opener: nil, size: nil)
+        Vocab.libro["actions/dialog/alert?#{{resource: resource, opener: opener, size: size}.compact.to_param}"]
       end
 
       def ontola_dialog_close_action

data/lib/linked_rails/helpers/resource_helper.rb

@@ -41,16 +41,28 @@ module LinkedRails
       end
 
       def requested_resource_parent
-        requested_resource&.parent
+        requested_resource.try(: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
@@ -59,7 +71,7 @@ module LinkedRails
 
       def resolve_current_resource
         case action_name
-        when 'create', 'new'
+        when 'create'
           new_resource
         else
           requested_resource

data/lib/linked_rails/iri_mapper.rb

@@ -12,6 +12,7 @@ module LinkedRails
       #   => {
       #     action: 'show',
       #     class: Resource,
+      #     iri: 'https://example.com/resource/1?foo=bar',
       #     params: {
       #       id: '1',
       #       foo: 'bar'
@@ -22,6 +23,7 @@ module LinkedRails
       #   => {
       #     action: 'index',
       #     class: Resource,
+      #     iri: 'https://example.com/resources?foo=bar',
       #     params: {
       #       foo: 'bar'
       #     }
@@ -35,38 +37,21 @@ module LinkedRails
         query = Rack::Utils.parse_nested_query(URI(iri.to_s).query)
         params = Rails.application.routes.recognize_path(iri.to_s, method: method)
 
-        route_params_to_opts(params.merge(query))
-      rescue ActionController::RoutingError
+        route_params_to_opts(params.merge(query), iri.to_s)
+      rescue ActionController::RoutingError, SystemStackError
         EMPTY_IRI_OPTS.dup
       end
 
-      def index_resource_from_iri(iri, user_context)
-        ensure_absolute_iri!(iri)
-
-        opts = opts_from_iri(iri)
-        index_resource_from_opts(opts, user_context)
-      end
-
-      def index_resource_from_iri!(iri, user_context)
-        index_resource_from_iri(iri, user_context) || raise(ActiveRecord::RecordNotFound)
-      end
-
-      def index_resource_from_opts(opts, user_context)
-        opts[:class]&.requested_index_resource(opts[:params], user_context) if opts[:action] == 'index'
-      end
-
       def parent_from_params(params, user_context)
         return unless params.key?(:parent_iri)
 
-        parent_iri = "/#{params[:parent_iri]}"
-        opts = LinkedRails.iri_mapper.opts_from_iri(parent_iri)
-        opts[:params] = params.except(:parent_iri, :singular_route).merge(opts[:params])
+        parent_iri = LinkedRails.iri(path: "/#{params[:parent_iri]}")
 
-        LinkedRails.iri_mapper.resource_from_opts(opts, user_context)
+        LinkedRails.iri_mapper.resource_from_iri(parent_iri, user_context)
       end
 
       def resource_from_iri(iri, user_context)
-        ensure_absolute_iri!(iri)
+        return nil unless absolute_iri?(iri)
 
         opts = opts_from_iri(iri)
         resource_from_opts(opts, user_context)
@@ -80,7 +65,7 @@ module LinkedRails
         opts[:class]&.requested_resource(opts, user_context)
       end
 
-      def route_params_to_opts(params)
+      def route_params_to_opts(params, iri)
         controller_class = class_for_controller(params[:controller])
 
         return EMPTY_IRI_OPTS.dup if controller_class.blank?
@@ -88,27 +73,17 @@ module LinkedRails
         {
           action: params[:action],
           class: controller_class,
-          params: params.except(:action, :controller)
+          iri: iri,
+          params: sanitized_route_params(controller_class, params)
         }.with_indifferent_access
       end
 
-      def single_resource_from_iri(iri, user_context)
-        ensure_absolute_iri!(iri)
-
-        opts = opts_from_iri(iri)
-        single_resource_from_opts(opts, user_context)
-      end
-
-      def single_resource_from_iri!(iri, user_context)
-        single_resource_from_iri(iri, user_context) || raise(ActiveRecord::RecordNotFound)
-      end
+      private
 
-      def single_resource_from_opts(opts, user_context)
-        opts[:class]&.requested_single_resource(opts[:params], user_context) unless opts[:params] == 'index'
+      def absolute_iri?(iri)
+        iri.present? && !URI(iri).relative?
       end
 
-      private
-
       def class_for_controller(controller)
         return if controller.blank?
 
@@ -117,8 +92,11 @@ module LinkedRails
           .try(:controller_class)
       end
 
-      def ensure_absolute_iri!(iri)
-        raise("An absolute url is expected. #{iri} is given.") if iri.blank? || URI(iri).relative?
+      def sanitized_route_params(controller_class, params)
+        new_params = params.except(:action, :controller)
+        nested_key = :"#{controller_class.name.tableize.singularize}_id"
+        new_params[:id] ||= new_params.delete(nested_key) if new_params.key?(nested_key)
+        new_params
       end
     end
   end

data/lib/linked_rails/middleware/error_handling.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module LinkedRails
+  module Middleware
+    class ErrorHandling
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        @app.call(env)
+      rescue StandardError => e
+        handle_error(env, e)
+      end
+
+      private
+
+      def controller_class(req)
+        controller = req.controller_class
+
+        return ApplicationController if controller == ActionDispatch::Request::PASS_NOT_FOUND
+
+        controller
+      rescue StandardError
+        ApplicationController
+      end
+
+      def controller_instance(env)
+        return env['action_controller.instance'] if env['action_controller.instance']
+
+        req = ActionDispatch::Request.new(env)
+        res = ApplicationController.make_response!(req)
+        controller = controller_class(req).new
+        controller.set_request!(req)
+        controller.set_response!(res)
+
+        controller
+      end
+
+      def handle_error(env, error)
+        controller = controller_instance(env)
+
+        controller.send(:handle_and_report_error, error)
+        error_response = controller.response
+        body = ActionDispatch::Response::RackBody.new(error_response)
+
+        [error_response.status, error_response.headers, body]
+      end
+    end
+  end
+end

data/lib/linked_rails/middleware/linked_data_params.rb

@@ -1,8 +1,13 @@
 # frozen_string_literal: true
 
+# require 'empathy/emp_json'
+
 module LinkedRails
   module Middleware
-    class LinkedDataParams # rubocop:disable Metrics/ClassLength
+    class LinkedDataParams
+      include ::Empathy::EmpJson::Helpers::Slices
+      include ::Empathy::EmpJson::Helpers::Parsing
+
       def initialize(app)
         @app = app
       end
@@ -10,40 +15,15 @@ module LinkedRails
       def call(env)
         req = Rack::Request.new(env)
         params_from_query(req)
-        params_from_graph(req)
+        params_from_slice(req)
 
         @app.call(env)
       end
 
       private
 
-      def add_param(hash, key, value) # rubocop:disable Metrics/MethodLength
-        case hash[key]
-        when nil
-          hash[key] = value
-        when Hash
-          hash[key].merge!(value)
-        when Array
-          hash[key].append(value)
-        else
-          hash[key] = [hash[key], value]
-        end
-        hash
-      end
-
-      def associated_class_from_params(reflection, graph, subject)
-        return reflection.klass unless reflection.polymorphic?
-
-        query = graph.query(subject: subject, predicate: Vocab.rdfv[:type])
-        if query.empty?
-          raise("No type given for '#{subject}' referenced by polymorphic association '#{reflection.name}'")
-        end
-
-        iri_to_class(query.first.object)
-      end
-
-      def blob_attribute(base_params, value)
-        base_params["<#{value}>"] if value.starts_with?(Vocab.ll['blobs/'])
+      def add_param_from_query(data, target_class, key, value)
+        data[target_class.predicate_mapping[RDF::URI(key)].key] = value
       end
 
       def convert_query_params(request, target_class)
@@ -56,76 +36,32 @@ module LinkedRails
         request.update_param(class_key, data) if data.present?
       end
 
-      def add_param_from_query(data, target_class, key, value)
-        data[target_class.predicate_mapping[RDF::URI(key)].key] = value
-      end
-
-      def enum_attribute(klass, key, value)
-        opts = RDF::Serializers.serializer_for(klass).try(:enum_options, key)
-        return if opts.blank?
-
-        opts.detect { |_k, options| options.iri == value }&.first&.to_s
-      end
-
-      def graph_from_request(request)
-        request_graph = request.delete_param("<#{Vocab.ll[:graph].value}>")
-        return if request_graph.blank?
+      def slice_from_request(request)
+        return unless request.content_type == Mime::Type.lookup_by_extension(:empjson).to_s
 
-        RDF::Graph.load(
-          request_graph[:tempfile].path,
-          content_type: request_graph[:type],
-          canonicalize: true,
-          intern: false
-        )
-      end
-
-      def iri_to_class(iri)
-        iri.to_s.split(LinkedRails.app_vocab.to_s).pop&.classify&.safe_constantize ||
-          ApplicationRecord.descendants.detect { |klass| klass.iri == iri }
-      end
-
-      def logger
-        Rails.logger
-      end
+        body = request.body.read
 
-      def nested_attributes(base_params, graph, subject, klass, association, collection) # rubocop:disable Metrics/ParameterLists
-        nested_resources =
-          if graph.query([subject, Vocab.rdfv[:first], nil]).present?
-            nested_attributes_from_list(base_params, graph, subject, klass)
-          else
-            parsed = parse_nested_resource(base_params, graph, subject, klass)
-            collection ? {rand(1_000_000_000).to_s => parsed} : parsed
-          end
-        ["#{association}_attributes", nested_resources]
+        JSON.parse(body) if body.present?
       end
 
-      def nested_attributes_from_list(base_params, graph, subject, klass)
-        Hash[
-          RDF::List.new(subject: subject, graph: graph)
-            .map { |nested| [rand(1_000_000_000).to_s, parse_nested_resource(base_params, graph, nested, klass)] }
-        ]
-      end
-
-      # Converts a serialized graph from a multipart request body to a nested
-      # attributes hash.
+      # Converts a emp slice from to a nested attributes hash.
       #
-      # 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
+      # The entrypoint for the slice is the `.` 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_graph(request)
-        graph = graph_from_request(request)
+      def params_from_slice(request)
+        slice = slice_from_request(request)
 
-        return unless graph
+        return unless slice
 
-        request.update_param(:body_graph, graph)
+        request.env['emp_json'] = slice
         target_class = target_class_from_path(request)
         return if target_class.blank?
 
-        update_actor_param(request, graph)
-        update_target_params(request, graph, target_class)
+        update_actor_param(request, slice)
+        update_target_params(request, slice, target_class)
       end
 
       def params_from_query(request)
@@ -135,87 +71,30 @@ module LinkedRails
         convert_query_params(request, target_class)
       end
 
-      def parse_nested_resource(base_params, graph, subject, klass)
-        resource = parse_resource(base_params, graph, subject, klass)
-        resource[:id] ||= LinkedRails.iri_mapper.opts_from_iri(subject)[:params][:id] if subject.iri?
-        resource
-      end
-
-      # Recursively parses a resource from graph
-      def parse_resource(base_params, graph, subject, klass)
-        graph
-          .query([subject])
-          .map { |statement| parse_statement(base_params, graph, statement, klass) }
-          .compact
-          .reduce({}) { |h, (k, v)| add_param(h, k, v) }
-      end
-
-      def parse_statement(base_params, graph, statement, klass)
-        field = serializer_field(klass, statement.predicate)
-        if field.is_a?(FastJsonapi::Attribute)
-          parsed_attribute(base_params, klass, field.key, statement.object.value)
-        elsif field.is_a?(FastJsonapi::Relationship)
-          parsed_association(base_params, graph, statement.object, klass, field.association || field.key)
-        end
-      end
-
-      def parsed_association(base_params, graph, object, klass, association)
-        reflection = klass.reflect_on_association(association) || raise("#{association} not found for #{klass}")
-
-        if graph.has_subject?(object)
-          association_klass = associated_class_from_params(reflection, graph, object)
-          nested_attributes(base_params, graph, object, association_klass, association, reflection.collection?)
-        elsif object.iri?
-          attributes_from_iri(object, association, reflection)
-        end
-      end
-
-      def attributes_from_iri(object, association, reflection)
-        if reflection.options[:through]
-          key = reflection.has_one? ? "#{association}_id" : "#{association.to_s.singularize}_ids"
-        elsif reflection.belongs_to?
-          key = reflection.foreign_key
-        end
-        return unless key
-
-        resource = LinkedRails.iri_mapper.resource_from_iri(object, nil)
-        value = resource&.send(reflection.association_primary_key)
-
-        [key, value] if value
-      end
-
-      def parsed_attribute(base_params, klass, key, value)
-        [key, blob_attribute(base_params, value) || enum_attribute(klass, key, value) || value]
-      end
-
-      def serializer_field(klass, predicate)
-        field = klass.try(:predicate_mapping).try(:[], predicate)
-        logger.info("#{predicate} not found for #{klass || 'nil'}") if field.blank?
-        field
-      end
-
       def target_class_from_path(request) # rubocop:disable Metrics/AbcSize
         opts = LinkedRails.iri_mapper.opts_from_iri(
           request.base_url + request.env['REQUEST_URI'],
           method: request.request_method
         )
 
-        logger.info("No class found for #{request.base_url + request.env['REQUEST_URI']}") unless opts[:class]
+        Rails.logger.info("No class found for #{request.base_url + request.env['REQUEST_URI']}") unless opts[:class]
 
         opts[:class]
       end
 
-      def update_actor_param(request, graph)
-        actor = graph.query([Vocab.ll[:targetResource], Vocab.schema.creator]).first
+      def update_actor_param(request, slice)
+        actor = values_from_slice(slice, '.', Vocab.schema.creator)
+
         return if actor.blank?
 
-        request.update_param(:actor_iri, actor.object)
-        graph.delete(actor)
+        request.update_param(:actor_iri, emp_to_primitive(actor))
       end
 
-      def update_target_params(request, graph, target_class)
+      def update_target_params(request, slice, target_class)
         key = target_class.to_s.demodulize.underscore
-        from_body = parse_resource(request.params, graph, Vocab.ll[:targetResource], target_class)
+
+        parser = ParamsParser.new(slice: slice, params: request.params)
+        from_body = parser.parse_resource('.', target_class)
 
         request.update_param(key, from_body.merge(request.params[key] || {}))
       end

data/lib/linked_rails/model/actionable.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module LinkedRails
+  module Model
+    module Actionable
+      extend ActiveSupport::Concern
+
+      def actions(user_context = nil)
+        action_list(user_context).actions
+      end
+
+      def action(tag, user_context = nil)
+        actions(user_context).find { |a| a.tag == tag }
+      end
+
+      def action_list(user_context)
+        @action_list ||= {}
+        @action_list[user_context] ||= self.class.action_list.new(resource: self, user_context: user_context)
+      end
+
+      def action_triples
+        @action_triples ||= triples_for_actions(actions) + triples_for_actions(collection_actions)
+      end
+
+      def collection_actions
+        (try(:collections) || []).map do |opts|
+          collection_for(opts[:name]).actions
+        end.flatten
+      end
+
+      def favorite_actions
+        actions.filter(&:favorite)
+      end
+
+      private
+
+      def triples_for_actions(actions)
+        actions.flat_map do |action|
+          [
+            [iri, action.predicate, action.iri],
+            [iri, Vocab.schema.potentialAction, action.iri]
+          ]
+        end
+      end
+
+      module ClassMethods
+        def action_list
+          @action_list ||= define_action_list
+        end
+
+        private
+
+        def action_superclass
+          superclass.try(:action_list) || LinkedRails.action_list_parent_class
+        end
+
+        def define_action_list
+          klass = Class.new(action_superclass)
+          actionable_class = self
+          klass.define_singleton_method(:actionable_class) do
+            actionable_class
+          end
+          klass
+        end
+      end
+    end
+  end
+end

data/lib/linked_rails/model/cacheable.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module LinkedRails
+  module Model
+    module Cacheable
+      extend ActiveSupport::Concern
+
+      included do
+        if respond_to?(:after_commit)
+          after_commit :publish_create, on: :create, if: :should_publish_changes
+          after_commit :publish_update, on: :update, if: :should_publish_changes
+          after_commit :publish_delete, on: :destroy, if: :should_publish_changes
+        end
+      end
+
+      def cacheable?
+        true
+      end
+
+      def publish_create
+        publish_message('io.ontola.transactions.Created')
+      end
+
+      def publish_update
+        publish_message('io.ontola.transactions.Updated')
+      end
+
+      def publish_delete
+        publish_message('io.ontola.transactions.Deleted')
+      end
+
+      private
+
+      def publish_message(type)
+        LinkedRails::InvalidationStreamWorker.perform_now(type, iri.to_s, self.class.iri.to_s)
+      rescue StandardError
+        LinkedRails::InvalidationStreamWorker.perform_later(type, iri.to_s, self.class.iri.to_s)
+      end
+
+      def should_publish_changes
+        cacheable? && !Rails.env.test?
+      end
+    end
+  end
+end