linked_rails 0.0.4.pre.gfe77aae19 → 0.0.4

data/app/controllers/linked_rails/bulk_controller.rb

@@ -11,8 +11,7 @@ module LinkedRails
     def show
       render json: authorized_resources
 
-      print_timings unless Rails.env.production?
-      send_timings if client
+      print_timings
     end
 
     private
@@ -21,11 +20,8 @@ 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)
 
-      return response_from_request(include, RDF::URI(opts[:iri])) if resource.blank?
-
-      response_from_resource(include, opts[:iri], resource)
+      response_from_request(include, RDF::URI(opts[:iri]))
     rescue StandardError => e
       handle_resource_error(opts, e)
     end
@@ -38,10 +34,6 @@ module LinkedRails
           .map(&method(:timed_authorized_resource))
     end
 
-    def client
-      nil
-    end
-
     def handle_resource_error(opts, error)
       log_resource_error(error, opts[:iri])
       status = error_status(error)
@@ -72,34 +64,29 @@ module LinkedRails
     def print_timings
       Rails.logger.debug(
         "\n  CPU        system     user+system real        inc   status  cache   iri\n" \
-        "#{timing_lines.join("\n")}\n" \
+        "#{timings.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_cache_control(cacheable, status, resource_policy)
-      return :private unless status == 200 && cacheable
-      return 'no-cache' unless resource_policy.try(:public_resource?)
+    def resource_body(resource)
+      return if resource.nil?
 
-      :public
+      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)
     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)
@@ -128,7 +115,7 @@ module LinkedRails
       fullpath = iri.query.blank? ? iri.path : "#{iri.path}?#{iri.query}"
 
       request.env.slice(*REQUEST_HEADERS).merge(
-        'HTTP_ACCEPT' => 'application/empathy+json',
+        'HTTP_ACCEPT' => 'application/hex+x-ndjson',
         'HTTP_OPERATOR_ARG_GRAPH' => 'true',
         'ORIGINAL_FULLPATH' => fullpath
       )
@@ -143,12 +130,6 @@ 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)
@@ -157,23 +138,6 @@ 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.to_s.split(vocab.to_s).last
@@ -182,30 +146,6 @@ module LinkedRails
       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)
@@ -241,8 +181,6 @@ module LinkedRails
         language: response_language(headers),
         status: status
       )
-    rescue URI::InvalidURIError, ActionController::BadRequest
-      resource_response(iri)
     end
 
     def response_language(headers)
@@ -251,7 +189,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.chomp('/').present? ? iri.to_s.split("#{LinkedRails.iri.path}/").last : iri)
+      uri = URI(LinkedRails.iri.path.present? ? iri.to_s.split("#{LinkedRails.iri.path}/").last : iri)
 
       [uri.path, uri.query].compact.join('?')
     end
@@ -263,13 +201,10 @@ module LinkedRails
     def timed_authorized_resource(resource)
       res = nil
       time = Benchmark.measure { res = authorized_resource(resource) }
-      timings << {
-        time: time,
-        include: resource[:include],
-        status: res[:status],
-        cache: res[:cache],
-        resource: resource[:iri]
-      }
+      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
       res
     end
 

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

@@ -8,13 +8,13 @@ module LinkedRails
       include ActiveModel::Model
       include LinkedRails::Model
 
-      attr_accessor :inherit, :list, :one_click, :policy_arguments, :submit_label, :target_path, :target_query
+      attr_accessor :inherit, :list, :one_click, :policy_arguments, :submit_label, :target_path
       attr_writer :parent, :resource, :root_relative_iri, :user_context, :object,
                   :target
       delegate :user_context, to: :list, allow_nil: true
       collection_options(
         association_base: lambda {
-          action_list = association_class.get_action_list(parent, user_context)
+          action_list = parent ? parent.action_list(user_context) : association_class.app_action_list(user_context)
 
           action_list.actions
         },
@@ -55,21 +55,37 @@ module LinkedRails
         @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
+        return {} if included_object.nil?
+
+        includes = included_object.class.try(:preview_includes)&.presence || []
+
+        (includes.is_a?(Hash) ? [includes] : includes) + (built_associations || [])
+      end
+
+      def included_object
+        object if object&.iri&.anonymous?
+      end
+
       def object
         @object = list.instance_exec(&@object) if @object.respond_to?(:call)
 
         @object || resource
       end
 
-      def object_iri
-        object&.iri&.anonymous? ? anonymous_object_iri : object&.iri
-      end
-
       def parent
         return @parent if instance_variable_defined?(:@parent)
 
@@ -98,6 +114,10 @@ module LinkedRails
         RDF::URI(value)
       end
 
+      def preview_includes
+        [:target, included_object: form_resource_includes]
+      end
+
       def singular_resource?
         resource.try(:singular_resource?)
       end
@@ -138,12 +158,6 @@ module LinkedRails
 
       private
 
-      def anonymous_object_iri
-        object_iri = iri.dup
-        object_iri.path += '/action_object'
-        object_iri
-      end
-
       def description_fallback
         LinkedRails.translate(:action, :description, self, false)
       end
@@ -157,7 +171,7 @@ module LinkedRails
       end
 
       def policy_resource_fallback
-        object
+        resource
       end
 
       def policy_valid?
@@ -185,10 +199,9 @@ module LinkedRails
         @root_relative_iri
       end
 
-      def target_url_fallback # rubocop:disable Metrics/AbcSize
+      def target_url_fallback
         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.path += "/#{target_path}" if target_path.present?
         base
       end
 
@@ -210,12 +223,6 @@ 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) if params.key?(:parent_iri)
 
@@ -229,7 +236,7 @@ module LinkedRails
           return nil if params[:id].blank?
 
           parent = parent_from_params!(params, user_context) if params.key?(:parent_iri)
-          action_list = get_action_list(parent, user_context)
+          action_list = parent ? parent.action_list(user_context) : app_action_list(user_context)
 
           action_list&.action(params[:id].to_sym)
         end

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

@@ -50,6 +50,12 @@ 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

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

@@ -9,10 +9,9 @@ module LinkedRails
       include LinkedRails::CallableVariable
 
       attr_accessor :key, :klass, :collection
-      attr_writer :options_array, :options_in, :visible
+      attr_writer :options_array, :options_in
       callable_variable(:options_array)
       callable_variable(:options_in)
-      callable_variable(:visible)
 
       def iri(**_opts)
         self
@@ -27,20 +26,8 @@ module LinkedRails
         Collection::FilterOption.new(attrs.merge(collection: collection, key: key))
       end
 
-      def visible?
-        has_options? && condition_valid?
-      end
-
-      private
-
-      def condition_valid?
-        return true if visible.nil?
-
-        visible
-      end
-
-      def has_options?
-        !!(options_in || options_array)
+      def serializable?
+        options_in || options_array
       end
     end
   end

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

@@ -14,7 +14,7 @@ module LinkedRails
       delegate :filter_options, to: :association_class
 
       def filter_fields
-        @filter_fields ||= filter_options&.map { |key, options| filter_field(key, options) }
+        @filter_fields ||= filter_options&.map { |key, options| filter_field(key, options) }&.select(&:serializable?)
       end
 
       def filtered?
@@ -51,10 +51,9 @@ module LinkedRails
       end
 
       def apply_filter(scope, key, values)
-        filter = filter_options[key].try(:[], :filter)
+        filter = filter_options.fetch(key).try(:[], :filter)
 
         return filter.call(scope, values) if filter
-        return scope unless association_class.predicate_mapping.key?(key)
 
         scope.where(association_class.predicate_mapping[key].key => values)
       end
@@ -73,14 +72,13 @@ module LinkedRails
           klass: association_class,
           key: key,
           options_in: options[:values_in],
-          options_array: options[:values],
-          visible: options[:visible]
+          options_array: options[:values]
         )
       end
 
       def sanitized_filter_value(key, value)
         mapping = association_class.predicate_mapping[key]
-        datatype = mapping.is_a?(FastJsonapi::Relationship) ? Vocab.xsd.anyURI : mapping&.datatype
+        datatype = mapping.is_a?(FastJsonapi::Relationship) ? Vocab.xsd.anyURI : mapping.datatype
         val = xsd_to_rdf(datatype, value)
         val.literal? ? val.object : val
       end

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

@@ -9,12 +9,6 @@ module LinkedRails
         attr_accessor :before
       end
 
-      def any?
-        return members_query.any? if members_query.is_a?(ActiveRecord::Relation)
-
-        count.positive?
-      end
-
       def initialize(orignial = {})
         attrs = orignial.with_indifferent_access
         attrs[:before] = attrs[:before]&.map { |val| val.with_indifferent_access }
@@ -30,7 +24,7 @@ module LinkedRails
         }
         next_view = collection.view_with_opts(current_opts.merge(before: next_before_values))
 
-        next_view.iri if next_view.any?
+        next_view.iri if next_view.count.positive?
       end
 
       def prev; end
@@ -59,15 +53,13 @@ module LinkedRails
       def before_values
         @before_values ||= before&.map do |value|
           sorting = collection.sortings.detect { |s| s.key == value[:key] }
-          next if sorting.nil?
-
           {
             attribute: sorting.attribute_name,
             direction: sorting.sort_direction,
             key: value[:key],
             value: value[:value]
           }
-        end.compact
+        end
       end
 
       def iri_opts
@@ -76,17 +68,14 @@ module LinkedRails
         }.merge(collection.iri_opts)
       end
 
-      def iris_from_scope; end
-
       def members_query
-        @members_query ||=
-          prepare_members(association_base)
-            .where(before_query)
-            .limit(page_size)
+        prepare_members(association_base)
+          .where(before_query)
+          .limit(page_size)
       end
 
       def next_before_values
-        last_record = members_query.last
+        last_record = members.last
         before_values.map do |val|
           value = last_record.send(val[:attribute])
           value = value.utc.iso8601(6) if value.is_a?(Time)

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

@@ -2,8 +2,8 @@
 
 module LinkedRails
   class Collection
-    module IRI
-      DEFAULT_IRI_TEMPLATE_KEYS = %i[before%5B%5D display filter%5B%5D page page_size sort%5B%5D table_type title type].freeze
+    module Iri
+      DEFAULT_IRI_TEMPLATE_KEYS = %i[before%5B%5D display filter%5B%5D page page_size sort%5B%5D title type].freeze
 
       extend ActiveSupport::Concern
 
@@ -11,7 +11,6 @@ module LinkedRails
         {
           parent_iri: parent_iri,
           display: @display,
-          table_type: @table_type,
           title: @title,
           type: @type,
           page_size: @page_size,
@@ -21,28 +20,6 @@ module LinkedRails
         }.compact
       end
 
-      def iri_template_opts
-        opts = iri_opts.with_indifferent_access.slice(*(DEFAULT_IRI_TEMPLATE_KEYS + iri_template_keys))
-        Hash[opts.keys.map { |key| [CGI.unescape(key).sub('[]', ''), opts[key]] }].to_param
-      end
-
-      def serialized_iri_template
-        iri_template
-          .to_s
-          .gsub('{route_key}', iri_template_route_key)
-          .gsub('{/parent_iri*}', iri_template_parent_iri)
-      end
-
-      private
-
-      def iri_template_parent_iri
-        parent&.iri&.to_s&.split('?')&.first || LinkedRails.iri
-      end
-
-      def iri_template_route_key
-        route_key.to_s
-      end
-
       class_methods do
         def iri
           [super, Vocab.as.Collection]

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

@@ -2,7 +2,7 @@
 
 module LinkedRails
   class Collection
-    module IRIMapping
+    module IriMapping
       extend ActiveSupport::Concern
 
       class_methods do

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

@@ -30,10 +30,9 @@ module LinkedRails
       end
 
       def members_query
-        @members_query ||=
-          prepare_members(association_base)
-            .page(page)
-            .per(page_size)
+        prepare_members(association_base)
+          .page(page)
+          .per(page_size)
       end
 
       def prepare_members(scope)

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

@@ -8,9 +8,8 @@ module LinkedRails
       include LinkedRails::Model
 
       attr_accessor :collection, :filter
-      delegate :apply_scope, :association_base, :association_class, :child_resource, :default_page_size, :display,
-               :include_members,:parent, :policy, :total_page_count, :unfiltered_collection, :user_context,
-               to: :collection
+      delegate :apply_scope, :association_base, :association_class, :default_page_size, :display,
+               :parent, :policy, :total_page_count, :unfiltered_collection, :user_context, to: :collection
       delegate :count, to: :members
 
       alias id iri
@@ -29,7 +28,7 @@ module LinkedRails
       end
 
       def members
-        @members ||= include_members ? members_array : iris_from_members
+        @members ||= raw_members
       end
 
       def members_iri
@@ -43,7 +42,9 @@ module LinkedRails
       end
 
       def preview_includes
-        include_members ? {member_sequence: :members} : %i[member_sequence]
+        return {member_sequence: {}} unless association_class.include_in_collection?
+
+        {member_sequence: {members: association_class.preview_includes}}
       end
 
       def title
@@ -61,39 +62,6 @@ module LinkedRails
         @arel_table ||= association_class.arel_table
       end
 
-      def iris_from_members
-        iris_from_scope || iris_from_records
-      end
-
-      def iris_from_records
-        members_query.map(&:iri)
-      end
-
-      def iris_from_scope
-        return unless iris_from_scope?
-
-        association_class.try(:iris_from_scope, members_query)
-      end
-
-      def iris_from_scope?
-        members_query.is_a?(ActiveRecord::Relation) && !polymorphic_collection?
-      end
-
-      def members_array
-        members_query.to_a
-      end
-
-      def polymorphic_collection?
-        column = association_class.inheritance_column
-        polymorphic = association_class.columns_hash.include?(column)
-        return false unless polymorphic
-
-        return true if association_class.descends_from_active_record?
-
-        members_query.where_values_hash.include?(column) &&
-          members_query.where_values_hash[column] != association_class.to_s
-      end
-
       def prepare_members(scope)
         if scope.respond_to?(:preload) && association_class.try(:includes_for_serializer)
           scope = scope.preload(association_class.includes_for_serializer)
@@ -101,6 +69,10 @@ module LinkedRails
         scope
       end
 
+      def raw_members
+        @raw_members ||= members_query.to_a
+      end
+
       class << self
         def iri
           [super, Vocab.as.CollectionPage]