linked_rails 0.0.3 → 0.0.4.pre.g14b377f91

data/lib/linked_rails/controller/error_handling.rb

@@ -6,12 +6,6 @@ module LinkedRails
       extend ActiveSupport::Concern
       include ActiveSupport::Rescuable
 
-      included do
-        rescue_from StandardError, with: :handle_and_report_error
-        rescue_from ActiveRecord::RecordNotFound, with: :handle_error
-        rescue_from Pundit::NotAuthorizedError, with: :handle_error
-      end
-
       private
 
       def add_error_snackbar(error)
@@ -22,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) }
@@ -30,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)

data/lib/linked_rails/controller/rendering.rb

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

data/lib/linked_rails/controller.rb

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

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

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

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

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

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

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

data/lib/linked_rails/enhancements.rb

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

data/lib/linked_rails/helpers/delta_helper.rb

@@ -3,61 +3,8 @@
 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 = 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)
-
-          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.ll[delta]
+        %i[remove replace invalidate].include?(delta) ? Vocab.ontola[delta] : Vocab.ld[delta]
       end
 
       def invalidate_collection_delta(collection)
@@ -65,7 +12,9 @@ module LinkedRails
       end
 
       def invalidate_parent_collections_delta(resource)
-        resource&.parent_collections(try(:user_context))&.map(&method(:invalidate_collection_delta)) || []
+        context = user_context if respond_to?(:user_context, true)
+
+        resource&.parent_collections(context)&.map(&method(:invalidate_collection_delta)) || []
       end
 
       def invalidate_resource_delta(resource)
@@ -75,11 +24,31 @@ module LinkedRails
       end
 
       def resource_added_delta(resource)
-        invalidate_parent_collections_delta(resource)
+        invalidate_parent_collections_delta(resource) + singular_added_delta(resource)
       end
 
       def resource_removed_delta(resource)
-        invalidate_parent_collections_delta(resource)
+        invalidate_parent_collections_delta(resource) + singular_removed_delta(resource)
+      end
+
+      def same_as_statement(from, to)
+        [
+          from,
+          Vocab.owl.sameAs,
+          to
+        ]
+      end
+
+      def singular_added_delta(resource)
+        return [] unless resource.try(:singular_resource?)
+
+        [same_as_statement(resource.singular_iri, resource.iri)]
+      end
+
+      def singular_removed_delta(resource)
+        return [] unless resource.try(:singular_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,7 +41,7 @@ module LinkedRails
       end
 
       def requested_resource_parent
-        requested_resource&.parent
+        requested_resource.try(:parent)
       end
 
       private
@@ -51,6 +51,8 @@ module LinkedRails
       end
 
       def new_resource_from_parent
+        return requested_resource.child_resource if requested_resource.is_a?(Collection)
+
         parent_resource.build_child(
           controller_class,
           user_context: user_context
@@ -59,7 +61,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))
+        route_params_to_opts(params.merge(query), iri.to_s)
       rescue ActionController::RoutingError
         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