linked_rails 0.0.1 → 0.0.4.pre.g0ec6e30ca

data/app/controllers/linked_rails/actions/objects_controller.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module LinkedRails
+  module Actions
+    class ObjectsController < LinkedRails.controller_parent_class
+      active_response :show
+    end
+  end
+end

data/app/controllers/linked_rails/bulk_controller.rb

@@ -11,7 +11,8 @@ module LinkedRails
     def show
       render json: authorized_resources
 
-      print_timings
+      print_timings unless Rails.env.production?
+      send_timings if client
     end
 
     private
@@ -20,8 +21,11 @@ module LinkedRails
       return response_for_wrong_host(opts) if wrong_host?(opts[:iri])
 
       include = opts[:include].to_s == 'true'
+      resource = LinkedRails.iri_mapper.resource_from_iri(request_path_to_url(opts[:iri]), user_context)
 
-      response_from_request(include, RDF::URI(opts[:iri]))
+      return response_from_request(include, RDF::URI(opts[:iri])) if resource.blank?
+
+      response_from_resource(include, opts[:iri], resource)
     rescue StandardError => e
       handle_resource_error(opts, e)
     end
@@ -30,12 +34,16 @@ module LinkedRails
       @authorized_resources ||=
         params
           .require(:resources)
-          .map { |param| param.permit(:include, :iri) }
+          .map { |param| resource_params(param) }
           .map(&method(:timed_authorized_resource))
     end
 
+    def client
+      nil
+    end
+
     def handle_resource_error(opts, error)
-      log_resource_error(error)
+      log_resource_error(error, opts[:iri])
       status = error_status(error)
       body = error_body(status, error, opts[:iri]) if opts[:include].to_s == 'true'
 
@@ -50,7 +58,7 @@ module LinkedRails
       resource_body(error_resource(status, error, iri))
     end
 
-    def log_resource_error(error)
+    def log_resource_error(error, _iri)
       return unless log_resource_error?(error)
 
       Rails.logger.error(error)
@@ -64,23 +72,34 @@ module LinkedRails
     def print_timings
       Rails.logger.debug(
         "\n  CPU        system     user+system real        inc   status  cache   iri\n" \
-        "#{timings.join("\n")}\n" \
+        "#{timing_lines.join("\n")}\n" \
         "  User: #{current_user.class}(#{current_user.id})"
       )
     end
 
+    def send_timings
+      timings.each do |timing|
+        client.send_json(timing_json(timing))
+      end
+    end
+
     def require_doorkeeper_token?
       false
     end
 
-    def resource_body(resource)
-      return if resource.nil?
+    def resource_cache_control(cacheable, status, resource_policy)
+      return :private unless status == 200 && cacheable
+      return 'no-cache' unless resource_policy.try(:public_resource?)
 
-      serializer_options = RDF::Serializers::Renderers.transform_opts(
-        {include: resource&.try(:preview_includes)},
-        serializer_params
-      )
-      RDF::Serializers.serializer_for(resource).new(resource, serializer_options).send(:render_hndjson)
+      :public
+    end
+
+    def resource_params(param)
+      params = param.permit(:include, :iri)
+      params[:iri] = URI(params[:iri])
+      params
+    rescue URI::InvalidURIError
+      params.except(:iri)
     end
 
     def resource_response_body(iri, rack_body, status)
@@ -109,7 +128,7 @@ module LinkedRails
       fullpath = iri.query.blank? ? iri.path : "#{iri.path}?#{iri.query}"
 
       request.env.slice(*REQUEST_HEADERS).merge(
-        'HTTP_ACCEPT' => 'application/hex+x-ndjson',
+        'HTTP_ACCEPT' => 'application/empathy+json',
         'HTTP_OPERATOR_ARG_GRAPH' => 'true',
         'ORIGINAL_FULLPATH' => fullpath
       )
@@ -124,6 +143,12 @@ module LinkedRails
       }.merge(opts)
     end
 
+    def resource_status(resource_policy)
+      raise(LinkedRails::Errors::Forbidden.new(query: :show?)) unless resource_policy.show?
+
+      200
+    end
+
     def response_for_wrong_host(opts)
       iri = opts[:iri]
       term = term_from_vocab(iri)
@@ -132,18 +157,73 @@ module LinkedRails
       ontology_term_response(iri, term, opts[:include])
     end
 
+    def response_from_resource(include, iri, resource)
+      resource_policy = policy(resource)
+      status = resource_status(resource_policy)
+
+      resource_response(
+        iri,
+        body: response_from_resource_body(include, iri, resource, status),
+        cache: resource_cache_control(resource.try(:cacheable?), status, resource_policy),
+        language: I18n.locale,
+        status: status
+      )
+    end
+
+    def response_from_resource_body(include, _iri, resource, status)
+      include && status == 200 ? resource_body(resource) : nil
+    end
+
     def term_from_vocab(iri)
       vocab = Vocab.for(iri)
-      tag = iri.split(vocab.to_s).last
+      tag = iri.to_s.split(vocab.to_s).last
       vocab[tag]
     rescue NoMethodError
       nil
     end
 
+    def timing_json(timing) # rubocop:disable Metrics/MethodLength
+      route = Rails.application.routes.recognize_path(timing[:resource].to_s)
+
+      {
+        type: 'web',
+        timings: {
+          total_duration: timing[:time].total
+        },
+        default_labels: {
+          action: route[:action] || 'show',
+          controller: route[:controller] || 'subresource',
+          status: timing[:status],
+          include: timing[:include]
+        }
+      }
+    end
+
+    def timing_lines
+      timings.map do |timing|
+        include = timing[:include].to_s.ljust(5)
+        "#{timing[:time].to_s[0..-2]} - #{include}  #{timing[:status]}   #{timing[:cache]} #{timing[:resource]}"
+      end
+    end
+
+    def ontology_class(iri)
+      klass = LinkedRails.linked_models.detect do |model|
+        (model.iri.is_a?(Array) ? model.iri : [model.iri]).include?(iri)
+      end
+      LinkedRails.ontology_class_class.new(iri: iri, klass: klass)
+    end
+
+    def ontology_property(iri)
+      LinkedRails.ontology_property_class.new(iri: iri)
+    end
+
     def ontology_term_response(iri, term, include)
+      capital = term.relativize(term.vocab).to_s[0] =~ /[A-Z]/
+      resource = capital ? ontology_class(term) : ontology_property(term)
+
       resource_response(
         iri,
-        body: include ? resource_body(LinkedRails.ontology_property_class.new(iri: term)) : nil,
+        body: include ? resource_body(resource) : nil,
         cache: :public,
         language: I18n.locale,
         status: 200
@@ -161,6 +241,8 @@ module LinkedRails
         language: response_language(headers),
         status: status
       )
+    rescue URI::InvalidURIError, ActionController::BadRequest
+      resource_response(iri)
     end
 
     def response_language(headers)
@@ -169,7 +251,7 @@ module LinkedRails
 
     def sanitized_relative_path(iri) # rubocop:disable Metrics/AbcSize
       iri.path = "#{iri.path}/" unless iri.path&.ends_with?('/')
-      uri = URI(LinkedRails.iri.path.present? ? iri.to_s.split("#{LinkedRails.iri.path}/").last : iri)
+      uri = URI(LinkedRails.iri.path.chomp('/').present? ? iri.to_s.split("#{LinkedRails.iri.path}/").last : iri)
 
       [uri.path, uri.query].compact.join('?')
     end
@@ -181,15 +263,18 @@ module LinkedRails
     def timed_authorized_resource(resource)
       res = nil
       time = Benchmark.measure { res = authorized_resource(resource) }
-      unless Rails.env.production?
-        include = resource[:include].to_s.ljust(5)
-        timings << "#{time.to_s[0..-2]} - #{include}  #{res[:status]}   #{res[:cache]} #{resource[:iri]}"
-      end
+      timings << {
+        time: time,
+        include: resource[:include],
+        status: res[:status],
+        cache: res[:cache],
+        resource: resource[:iri]
+      }
       res
     end
 
     def wrong_host?(iri)
-      !iri.starts_with?(LinkedRails.iri)
+      !iri.to_s.starts_with?(LinkedRails.iri)
     end
   end
 end

data/app/controllers/linked_rails/enum_values_controller.rb

@@ -3,47 +3,5 @@
 module LinkedRails
   class EnumValuesController < LinkedRails.controller_parent_class
     active_response :index
-
-    private
-
-    def enum_options!
-      serializer_class!.enum_options(params[:attribute]) || raise(ActiveRecord::RecordNotFound)
-    end
-
-    def requested_resource
-      return super unless action_name == 'index'
-
-      @requested_resource ||= LinkedRails::Sequence.new(
-        enum_options!.values,
-        id: index_iri,
-        scope: LinkedRails::EnumValuePolicy::Scope
-      )
-    end
-
-    def model_class
-      @model_class ||= self.class.linked_models.detect do |klass|
-        klass.to_s == ([params[:module]].compact + [params[:klass]&.singularize]).join('/').classify
-      end
-    end
-
-    def model_class!
-      model_class || raise(ActiveRecord::RecordNotFound)
-    end
-
-    def serializer_class
-      @serializer_class ||= RDF::Serializers.serializer_for(model_class!)
-    end
-
-    def serializer_class!
-      serializer_class || raise(ActiveRecord::RecordNotFound)
-    end
-
-    class << self
-      def linked_models
-        @linked_models ||= ObjectSpace.each_object(Class).select do |c|
-          c.included_modules.include?(LinkedRails::Model)
-        end
-      end
-    end
   end
 end

data/app/models/linked_rails/actions/item.rb

@@ -7,15 +7,23 @@ module LinkedRails
     class Item # rubocop:disable Metrics/ClassLength
       include ActiveModel::Model
       include LinkedRails::Model
-      enhance LinkedRails::Enhancements::Singularable
 
-      attr_accessor :list, :policy_arguments, :submit_label
+      attr_accessor :inherit, :list, :one_click, :policy_arguments, :submit_label, :target_path, :target_query
       attr_writer :parent, :resource, :root_relative_iri, :user_context, :object,
                   :target
       delegate :user_context, to: :list, allow_nil: true
-
-      %i[description result type policy label image url include_object include_paths collection condition form completed
-         tag http_method favorite path policy_resource predicate resource].each do |method|
+      collection_options(
+        association_base: lambda {
+          action_list = association_class.get_action_list(parent, user_context)
+
+          action_list.actions
+        },
+        display: :grid,
+        title: -> { I18n.t('actions.plural') }
+      )
+
+      %i[condition description result type policy label image target_url collection form
+         tag http_method favorite action_path policy_resource predicate resource].each do |method|
         attr_writer method
         define_method method do
           var = instance_variable_get(:"@#{method}")
@@ -28,10 +36,10 @@ module LinkedRails
 
       def action_status
         @action_status ||=
-          if completed
-            Vocab.schema.CompletedActionStatus
-          elsif policy_valid?
+          if policy_valid?
             Vocab.schema.PotentialActionStatus
+          elsif policy_status
+            policy_status
           elsif policy_expired?
             Vocab.ontola[:ExpiredActionStatus]
           else
@@ -39,46 +47,29 @@ module LinkedRails
           end
       end
 
-      def as_json(_opts = {})
+      def as_json(**_opts)
         {}
       end
 
       def available?
-        return false unless action_status == Vocab.schema.PotentialActionStatus
-
         @condition.nil? || condition
       end
 
-      def built_associations
-        included_object
-          .class
-          .try(:reflect_on_all_associations)
-          &.select { |association| included_object.association(association.name).loaded? }
-          &.map(&:name)
-      end
-
       def error
         policy_message ||
           I18n.t("actions.status.#{action_status.to_s.split('#').last}", default: nil)
       end
 
-      def form_resource_includes # rubocop:disable Metrics/CyclomaticComplexity
-        return {} if included_object.nil?
-        return include_paths || {} if iri.anonymous?
-
-        includes = included_object.class.try(:preview_includes)&.presence || []
-
-        (includes.is_a?(Hash) ? [includes] : includes) + (built_associations || [])
+      def object
+        object_from_var || resource
       end
 
-      def included_object
-        object if include_object || object&.iri&.anonymous?
+      def object_iri
+        iri_with_root(object_root_relative_iri)
       end
 
-      def object
-        @object = list.instance_exec(&@object) if @object.respond_to?(:call)
-
-        @object || resource
+      def object_root_relative_iri
+        object&.iri&.anonymous? ? anonymous_object_root_relative_iri : object&.root_relative_iri
       end
 
       def parent
@@ -92,10 +83,10 @@ module LinkedRails
       end
 
       def policy_message
-        resource_policy.try(:message) if action_status == Vocab.ontola[:DisabledActionStatus]
+        resource_policy.try(:message) unless policy_valid?
       end
 
-      def root_relative_iri(_opts = {})
+      def root_relative_iri(**_opts)
         value = root_relative_iri_from_var
         value = RDF::URI(value) unless value.blank? || value.is_a?(RDF::URI)
         return @root_relative_iri = value if value
@@ -109,24 +100,30 @@ module LinkedRails
         RDF::URI(value)
       end
 
-      def preview_includes
-        [:target, included_object: form_resource_includes]
-      end
-
       def singular_resource?
         resource.try(:singular_resource?)
       end
 
+      def policy_status
+        resource_policy.try(:action_status)
+      end
+
       def iri_opts
-        resource&.iri_opts || {}
+        return {} if resource.blank?
+
+        resource.try(:singular_resource?) ? resource.singular_iri_opts : resource.iri_opts
       end
 
       def iri_template
-        path_suffix = path.blank? ? "/actions/#{tag}" : "/#{path}"
+        path_suffix = "/#{action_path || tag}"
 
-        return @iri_template ||= URITemplate.new(path_suffix) if resource.blank?
+        return @iri_template ||= LinkedRails::URITemplate.new(path_suffix) if resource.blank?
 
-        @iri_template ||= iri_template_expand_path(resource.send(:iri_template), path_suffix)
+        base_template = resource.send(resource.try(:singular_resource?) ? :singular_iri_template : :iri_template)
+        @iri_template ||= iri_template_expand_path(
+          base_template.to_s.sub('display,', '').sub('sort%5B%5D*,', ''),
+          path_suffix
+        )
       end
 
       def rdf_type
@@ -143,6 +140,12 @@ module LinkedRails
 
       private
 
+      def anonymous_object_root_relative_iri
+        object_iri = root_relative_iri.dup
+        object_iri.path += '/action_object'
+        object_iri
+      end
+
       def description_fallback
         LinkedRails.translate(:action, :description, self, false)
       end
@@ -151,12 +154,18 @@ module LinkedRails
         LinkedRails.translate(:action, :label, self)
       end
 
+      def object_from_var
+        return @object unless @object.respond_to?(:call)
+
+        @object = list.instance_exec(&@object)
+      end
+
       def policy_expired?
         @policy_expired ||= policy && resource_policy.try(:expired?)
       end
 
       def policy_resource_fallback
-        resource
+        object
       end
 
       def policy_valid?
@@ -184,6 +193,13 @@ module LinkedRails
         @root_relative_iri
       end
 
+      def target_url_fallback # rubocop:disable Metrics/AbcSize
+        base = (resource.try(:singular_resource?) ? resource.singular_iri : resource.iri).dup
+        base.path = "#{base.path.chomp('/')}/#{target_path}" if target_path.present?
+        base.query = Rack::Utils.parse_nested_query(base.query).merge(target_query).to_param if target_query.present?
+        base
+      end
+
       def type_fallback
         Vocab.schema.UpdateAction
       end
@@ -202,25 +218,26 @@ module LinkedRails
           )
         end
 
+        def get_action_list(parent, user_context)
+          return parent.action_list(user_context) if parent.respond_to?(:action_list)
+
+          app_action_list(user_context)
+        end
+
         def requested_index_resource(params, user_context)
-          parent = parent_from_params(params, user_context)
-          action_list = parent ? parent.action_list(user_context) : app_action_list(user_context)
-
-          LinkedRails.collection_class.new(
-            association_base: action_list.actions,
-            association_class: ::Actions::Item,
-            default_display: :grid,
-            default_title: I18n.t('actions.plural'),
-            parent: parent,
-            title: params[:title]
+          parent = parent_from_params!(params, user_context) if params.key?(:parent_iri)
+
+          default_collection_option(:collection_class).collection_or_view(
+            default_collection_options.merge(parent: parent),
+            index_collection_params(params, user_context)
           )
         end
 
         def requested_single_resource(params, user_context)
           return nil if params[:id].blank?
 
-          parent = parent_from_params(params, user_context)
-          action_list = parent ? parent.action_list(user_context) : app_action_list(user_context)
+          parent = parent_from_params!(params, user_context) if params.key?(:parent_iri)
+          action_list = get_action_list(parent, user_context)
 
           action_list&.action(params[:id].to_sym)
         end

data/app/models/linked_rails/actions/list.rb

@@ -7,14 +7,12 @@ module LinkedRails
     class List
       include ActiveModel::Model
       include LinkedRails::Model
-      include DefaultActions
-      extend LinkedRails::Enhanceable
 
       attr_accessor :resource, :user_context
       class_attribute :_defined_actions, instance_reader: false, instance_writer: false
 
       def actions
-        @actions ||= defined_actions.map { |tag, opts| action_item(tag, opts.dup) }
+        @actions ||= defined_actions.map { |tag, opts| action_item(tag, opts.dup) }.select(&:available?)
       end
 
       def action(tag)
@@ -34,9 +32,9 @@ module LinkedRails
       private
 
       def action_item(tag, options)
-        options[:tag] ||= options[:action_tag] || tag
+        options[:tag] ||= tag
         options[:list] ||= self
-        LinkedRails.actions_item_class.new(options.except(:action_tag))
+        LinkedRails.actions_item_class.new(options.except(:action_name))
       end
 
       def association
@@ -52,12 +50,6 @@ module LinkedRails
       end
 
       class << self
-        def actionable_class
-          @actionable_class ||=
-            name.gsub('ActionList', '').safe_constantize ||
-            name.demodulize.gsub('ActionList', '').safe_constantize
-        end
-
         def collection_actions
           defined_actions[:collection]
         end
@@ -77,26 +69,11 @@ module LinkedRails
 
         private
 
-        def has_collection_action(action, opts = {}) # rubocop:disable Naming/PredicateName
-          opts[:http_method] ||= 'POST'
-          defined_actions[:collection][action] = opts
-        end
-
-        def has_resource_action(action, opts = {}) # rubocop:disable Naming/PredicateName
-          opts[:http_method] ||= 'POST'
-          defined_actions[:resource][action] = opts
-        end
-
-        def has_singular_action(action, opts = {}) # rubocop:disable Naming/PredicateName
-          opts[:http_method] ||= 'POST'
-          defined_actions[:singular][action] = opts
-        end
-
         def initial_defined_actions(clone_from = {})
           {
-            collection: clone_from[:collection].dup || {},
-            resource: clone_from[:resource].dup || {},
-            singular: clone_from[:singular].dup || {}
+            collection: clone_from[:collection].dup&.select { |_, value| value[:inherit] != false } || {},
+            resource: clone_from[:resource].dup&.select { |_, value| value[:inherit] != false } || {},
+            singular: clone_from[:singular].dup&.select { |_, value| value[:inherit] != false } || {}
           }
         end
 
@@ -106,8 +83,6 @@ module LinkedRails
           self._defined_actions = initial_defined_actions(superclass.try(:_defined_actions) || {})
         end
       end
-
-      enhanceable :actionable_class, :Action
     end
   end
 end

data/app/models/linked_rails/actions/object.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require 'pundit'
+
+module LinkedRails
+  module Actions
+    class Object
+      include ActiveModel::Model
+      include LinkedRails::Model
+
+      attr_accessor :action
+      alias parent action
+      delegate :object, to: :action
+
+      def root_relative_iri
+        action.object_root_relative_iri
+      end
+
+      class << self
+        def requested_resource(opts, user_context)
+          return super unless opts[:iri].include?('?')
+
+          parent_iri_with_query = [opts[:params][:parent_iri], opts[:iri].split('?').last].compact.join('?')
+
+          super(opts.merge(params: opts[:params].merge(parent_iri: parent_iri_with_query)), user_context)
+        end
+
+        def requested_single_resource(params, user_context)
+          return unless params.key?(:parent_iri)
+
+          parent = parent_from_params!(params, user_context)
+
+          object = parent&.object
+          object.instance_variable_set(:@iri, parent.object_iri)
+          object
+        end
+      end
+    end
+  end
+end

data/app/models/linked_rails/collection/configuration.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module LinkedRails
+  class Collection
+    module Configuration
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+        private
+
+        def define_default_option_method(option)
+          attr_accessor "default_#{option}"
+        end
+
+        def define_getter_option_method(option)
+          attr_writer option
+
+          define_method(option) do
+            resolve_collection_option(option)
+          end
+        end
+      end
+
+      included do
+        attr_accessor :iri_template
+
+        LinkedRails::Model::Collections::COLLECTION_CUSTOMIZABLE_OPTIONS.each_key do |option|
+          define_default_option_method(option)
+        end
+        LinkedRails::Model::Collections::COLLECTION_OPTIONS.each_key do |option|
+          define_getter_option_method(option)
+        end
+
+        def display
+          resolve_collection_option(:display)&.to_sym
+        end
+
+        def type
+          resolve_collection_option(:type)&.to_sym
+        end
+      end
+
+      private
+
+      def resolve_collection_option(option)
+        var_name = :"@#{option}"
+        default_method_name = "default_#{option}"
+
+        var = instance_variable_defined?(var_name) ? instance_variable_get(var_name) : try(default_method_name)
+
+        var.respond_to?(:call) ? instance_exec(&var) : var
+      end
+    end
+  end
+end