linked_rails 0.0.3 → 0.0.4.pre.g9b7bc9073

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

@@ -5,12 +5,7 @@ module LinkedRails
     module Filterable
       include RDF::Serializers::DataTypeHelper
 
-      attr_writer :default_filters, :filter, :unfiltered_collection
-
-      def default_filters
-        opts = @default_filters || association_class.try(:default_filters) || {}
-        opts.respond_to?(:call) ? opts.call(parent) : opts
-      end
+      attr_writer :filter, :unfiltered_collection
 
       def filter
         default_filters.merge(@filter || {})
@@ -56,9 +51,10 @@ module LinkedRails
       end
 
       def apply_filter(scope, key, values)
-        filter = filter_options.fetch(key).try(:[], :filter)
+        filter = filter_options[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
@@ -77,13 +73,14 @@ module LinkedRails
           klass: association_class,
           key: key,
           options_in: options[:values_in],
-          options_array: options[:values]
+          options_array: options[:values],
+          visible: options[:visible]
         )
       end
 
       def sanitized_filter_value(key, value)
         mapping = association_class.predicate_mapping[key]
-        datatype = mapping.is_a?(FastJsonapi::Relationship) ? RDF.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

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+module LinkedRails
+  class Collection
+    module Infinite
+      extend ActiveSupport::Concern
+
+      included do
+        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 }
+        super(attrs)
+      end
+
+      def next
+        return if before.blank? || members.blank?
+
+        current_opts = {
+          collection: collection,
+          filter: filter
+        }
+        next_view = collection.view_with_opts(current_opts.merge(before: next_before_values))
+
+        next_view.iri if next_view.any?
+      end
+
+      def prev; end
+
+      def type
+        :infinite
+      end
+
+      private
+
+      def additional_statements(arel, index)
+        (preconditions(index) + [arel]).reduce { |or_acc, or_value| or_acc.and(or_value) }
+      end
+
+      def before_iri_opts
+        before&.map { |hash| "#{CGI.escape(hash[:key])}=#{hash[:value]}" }
+      end
+
+      def before_query
+        before_values.each_with_index.reduce(nil) do |acc, (value, index)|
+          arel = arel_table[value[:attribute]].send(value[:direction], value[:value])
+          acc.nil? ? arel : acc.or(additional_statements(arel, index))
+        end
+      end
+
+      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
+
+      def iri_opts
+        {
+          'before%5B%5D': before_iri_opts
+        }.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)
+      end
+
+      def next_before_values
+        last_record = members_query.last
+        before_values.map do |val|
+          value = last_record.send(val[:attribute])
+          value = value.utc.iso8601(6) if value.is_a?(Time)
+          {
+            key: val[:key],
+            value: value
+          }
+        end
+      end
+
+      def preconditions(index)
+        before_values[0...index].map do |v|
+          condition = arel_table[v[:attribute]].eq(v[:value])
+          condition = condition.or(arel_table[v[:attribute]].eq(nil)) if v[:direction] == :gt
+          condition
+        end
+      end
+
+      def sort_column
+        @sort_column ||= collection.sortings.last.sort_value.keys.first
+      end
+    end
+  end
+end

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

@@ -3,96 +3,7 @@
 module LinkedRails
   class Collection
     class InfiniteView < LinkedRails.collection_view_class
-      attr_accessor :before
-
-      def initialize(orignial = {})
-        attrs = orignial.with_indifferent_access
-        attrs[:before] = attrs[:before]&.map { |val| val.with_indifferent_access }
-        super(attrs)
-      end
-
-      def next
-        return if before.blank? || members.blank?
-
-        current_opts = {
-          collection: collection,
-          filter: filter
-        }
-        next_view = collection.view_with_opts(current_opts.merge(before: next_before_values))
-
-        next_view.iri if next_view.count.positive?
-      end
-
-      def prev; end
-
-      def type
-        :infinite
-      end
-
-      private
-
-      def additional_statements(arel, index)
-        (preconditions(index) + [arel]).reduce { |or_acc, or_value| or_acc.and(or_value) }
-      end
-
-      def before_iri_opts
-        before&.map { |hash| "#{CGI.escape(hash[:key])}=#{hash[:value]}" }
-      end
-
-      def before_query
-        before_values.each_with_index.reduce(nil) do |acc, (value, index)|
-          arel = arel_table[value[:attribute]].send(value[:direction], value[:value])
-          acc.nil? ? arel : acc.or(additional_statements(arel, index))
-        end
-      end
-
-      def before_values
-        @before_values ||= before&.map do |value|
-          sorting = collection.sortings.detect { |s| s.key == value[:key] }
-          {
-            attribute: sorting.attribute_name,
-            direction: sorting.sort_direction,
-            key: value[:key],
-            value: value[:value]
-          }
-        end
-      end
-
-      def iri_opts
-        {
-          'before%5B%5D': before_iri_opts
-        }.merge(collection.iri_opts)
-      end
-
-      def members_query
-        prepare_members(association_base)
-          .where(before_query)
-          .limit(page_size)
-      end
-
-      def next_before_values
-        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)
-          {
-            key: val[:key],
-            value: value
-          }
-        end
-      end
-
-      def preconditions(index)
-        before_values[0...index].map do |v|
-          condition = arel_table[v[:attribute]].eq(v[:value])
-          condition = condition.or(arel_table[v[:attribute]].eq(nil)) if v[:direction] == :gt
-          condition
-        end
-      end
-
-      def sort_column
-        @sort_column ||= collection.sortings.last.sort_value.keys.first
-      end
+      include LinkedRails::Collection::Infinite
     end
   end
 end

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

@@ -2,55 +2,45 @@
 
 module LinkedRails
   class Collection
-    module Iri
-      extend ActiveSupport::Concern
+    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
 
-      included do
-        attr_writer :iri_template
-      end
+      extend ActiveSupport::Concern
 
       def iri_opts
-        opts = {}
-        iri_opts_add(opts, :display, display) if @display
-        iri_opts_add(opts, :title, title) if @title
-        iri_opts_add(opts, :type, type) if @type
-        iri_opts_add(opts, :page_size, page_size) if @page_size
-        iri_opts_add(opts, :'filter%5B%5D', filter_iri_opts)
-        iri_opts_add(opts, :'sort%5B%5D', sort_iri_opts)
-        opts
-      end
-
-      def iri_template
-        @iri_template ||=
-          URITemplate.new(
-            [
-              LinkedRails.iri(
-                path: [parent&.root_relative_iri&.to_s&.split('?')&.first, association_class.route_key].join('/')
-              ),
-              "{?#{self.class.iri_template_parsed_keys}}"
-            ].join('')
-          )
+        {
+          parent_iri: parent_iri,
+          display: @display,
+          table_type: @table_type,
+          title: @title,
+          type: @type,
+          page_size: @page_size,
+          filter: self.class.filter_iri_opts(@filter),
+          route_key: route_key,
+          sort: self.class.sort_iri_opts(@sort)
+        }.compact
       end
 
       def iri_template_opts
-        opts = iri_opts.with_indifferent_access.slice(*self.class.iri_template_keys)
+        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 filter_iri_opts
-        @filter&.map do |key, values|
-          predicate = key.is_a?(RDF::URI) ? key : association_class.predicate_for_key(key)
-
-          values.map { |value| "#{CGI.escape(predicate.to_s)}=#{CGI.escape(value.to_s)}" }
-        end&.flatten
+      def serialized_iri_template
+        iri_template
+          .to_s
+          .gsub('{route_key}', iri_template_route_key)
+          .gsub('{/parent_iri*}', iri_template_parent_iri)
       end
 
-      def iri_opts_add(opts, key, value)
-        opts[key] = value if value.present?
+      private
+
+      def iri_template_parent_iri
+        parent&.iri&.to_s&.split('?')&.first || LinkedRails.iri
       end
 
-      def sort_iri_opts
-        sort&.map { |s| "#{CGI.escape(s[:key].to_s)}=#{s[:direction]}" }
+      def iri_template_route_key
+        route_key.to_s
       end
 
       class_methods do
@@ -58,15 +48,29 @@ module LinkedRails
           [super, Vocab.as.Collection]
         end
 
-        def iri_template_keys
-          @iri_template_keys ||= %i[before%5B%5D display filter%5B%5D page page_size sort%5B%5D title type]
+        def filter_iri_opts(filters)
+          return nil if filters.blank?
+
+          Hash[
+            filters.map do |key, values|
+              predicate = key.is_a?(RDF::URI) ? key : association_class.predicate_for_key(key)
+              [predicate, values]
+            end
+          ]
+        end
+
+        def generate_iri_template(iri_template_keys)
+          URITemplate.new("{/parent_iri*}/{route_key}{?#{parse_iri_template_keys(iri_template_keys)}}")
         end
 
-        def iri_template_parsed_keys
-          @iri_template_parsed_keys ||=
-            iri_template_keys
-              .map { |k| k.to_s.ends_with?('%5B%5D') ? "#{k}*" : k.to_s }
-              .join(',')
+        def parse_iri_template_keys(keys)
+          (DEFAULT_IRI_TEMPLATE_KEYS + keys).map { |k| k.to_s.ends_with?('%5B%5D') ? "#{k}*" : k.to_s }.join(',')
+        end
+
+        def sort_iri_opts(sortings)
+          return nil if sortings.blank?
+
+          Hash[sortings.map { |s| [s[:key], s[:direction]] }]
         end
       end
     end

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

@@ -2,14 +2,14 @@
 
 module LinkedRails
   class Collection
-    module IriMapping
+    module IRIMapping
       extend ActiveSupport::Concern
 
       class_methods do
         def collection_or_view(options, params)
-          parser = params_parser_class.new(params)
-          collection = new(options.merge(collection_params(parser)))
-          view_params = collection_view_params(parser)
+          params_parser = params_parser_class.new(params)
+          collection = new(**merge_collection_opts(options, params_parser))
+          view_params = collection_view_params(params_parser)
 
           view_params.present? ? collection&.view_with_opts(view_params) : collection
         end
@@ -20,12 +20,20 @@ module LinkedRails
           parser.collection_params
         end
 
-        def collection_view_params(parser)
-          parser.collection_view_params
+        def collection_view_params(params_parser)
+          params_parser.collection_view_params
+        end
+
+        def merge_collection_opts(options, params_parser)
+          transformed_options = options.transform_keys do |key|
+            LinkedRails::Model::Collections::COLLECTION_CUSTOMIZABLE_OPTIONS.key?(key.to_sym) ? "default_#{key}" : key
+          end
+
+          transformed_options.merge(collection_params(params_parser))
         end
 
         def params_parser_class
-          LinkedRails::ParamsParser
+          LinkedRails::CollectionParamsParser
         end
       end
     end

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

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module LinkedRails
+  class Collection
+    module Paginated
+      extend ActiveSupport::Concern
+
+      included do
+        attr_accessor :page
+      end
+
+      def next
+        return if page.nil? || page.to_i >= (total_page_count || 0)
+
+        iri_with_root(root_relative_iri(page: page.to_i + 1))
+      end
+
+      def prev
+        return if page.nil? || page.to_i <= 1
+
+        iri_with_root(root_relative_iri(page: page.to_i - 1))
+      end
+
+      private
+
+      def iri_opts
+        {
+          page: page
+        }.merge(collection.iri_opts)
+      end
+
+      def members_query
+        @members_query ||=
+          prepare_members(association_base)
+            .page(page)
+            .per(page_size)
+      end
+
+      def prepare_members(scope)
+        return super unless scope.is_a?(Array) && !scope.is_a?(Kaminari::PaginatableArray)
+
+        Kaminari.paginate_array(super)
+      end
+    end
+  end
+end

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

@@ -3,39 +3,7 @@
 module LinkedRails
   class Collection
     class PaginatedView < LinkedRails.collection_view_class
-      attr_accessor :page
-
-      def next
-        return if page.nil? || page.to_i >= (total_page_count || 0)
-
-        iri_with_root(root_relative_iri(page: page.to_i + 1))
-      end
-
-      def prev
-        return if page.nil? || page.to_i <= 1
-
-        iri_with_root(root_relative_iri(page: page.to_i - 1))
-      end
-
-      private
-
-      def iri_opts
-        {
-          page: page
-        }.merge(collection.iri_opts)
-      end
-
-      def members_query
-        prepare_members(association_base)
-          .page(page)
-          .per(page_size)
-      end
-
-      def prepare_members(scope)
-        return super unless scope.is_a?(Array) && !scope.is_a?(Kaminari::PaginatableArray)
-
-        Kaminari.paginate_array(super)
-      end
+      include LinkedRails::Collection::Paginated
     end
   end
 end

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

@@ -4,7 +4,7 @@ module LinkedRails
   class Collection
     module Sortable
       attr_accessor :sort
-      attr_writer :default_sortings, :sort_options
+      attr_writer :sort_options
 
       def default_before_value
         sortings.map do |sorting|
@@ -15,14 +15,6 @@ module LinkedRails
         end
       end
 
-      def default_sortings
-        opts =
-          @default_sortings ||
-          association_class.try(:default_sortings) ||
-          [{key: Vocab.schema.dateCreated, direction: :desc}]
-        opts.respond_to?(:call) ? opts.call(parent) : opts
-      end
-
       def parsed_sort_values
         sortings.map(&:sort_value)
       end

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

@@ -33,7 +33,7 @@ module LinkedRails
       end
       # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength
 
-      def iri(_opts = {})
+      def iri(**_opts)
         self
       end
 

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

@@ -8,14 +8,14 @@ module LinkedRails
       include LinkedRails::Model
 
       attr_accessor :collection, :filter
-      delegate :apply_scope, :association_base, :association_class, :default_page_size, :display,
+      delegate :apply_scope, :association_base, :association_class, :default_page_size, :display, :include_members,
                :parent, :policy, :total_page_count, :unfiltered_collection, :user_context, to: :collection
       delegate :count, to: :members
 
       alias id iri
 
-      def root_relative_iri(opts = {})
-        collection.unfiltered.root_relative_iri(iri_opts.merge(opts))
+      def root_relative_iri(**opts)
+        collection.unfiltered.root_relative_iri(**iri_opts.merge(opts))
       end
 
       def member_sequence
@@ -28,7 +28,7 @@ module LinkedRails
       end
 
       def members
-        @members ||= raw_members
+        @members ||= include_members ? members_array : iris_from_members
       end
 
       def members_iri
@@ -42,9 +42,7 @@ module LinkedRails
       end
 
       def preview_includes
-        return {member_sequence: {}} unless association_class.include_in_collection?
-
-        {member_sequence: {members: association_class.preview_includes}}
+        include_members ? {member_sequence: :members} : %i[member_sequence]
       end
 
       def title
@@ -62,6 +60,39 @@ 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)
@@ -69,24 +100,20 @@ module LinkedRails
         scope
       end
 
-      def raw_members
-        @raw_members ||= members_query.to_a
-      end
-
       class << self
         def iri
           [super, Vocab.as.CollectionPage]
         end
 
-        def new(opts = {})
+        def new(**opts)
           type = opts.delete(:type)&.to_sym
           return super if type.nil?
 
           case type
           when :paginated
-            LinkedRails.collection_paginated_view_class.new(opts)
+            collection_paginated_view_class.new(**opts)
           when :infinite
-            LinkedRails.collection_infinite_view_class.new(opts)
+            collection_infinite_view_class.new(**opts)
           else
             raise ActionController::BadRequest, "'#{type}' is not a valid collection type"
           end
@@ -95,6 +122,16 @@ module LinkedRails
         def policy_class
           LinkedRails::Collection::ViewPolicy
         end
+
+        private
+
+        def collection_paginated_view_class
+          LinkedRails.collection_paginated_view_class
+        end
+
+        def collection_infinite_view_class
+          LinkedRails.collection_infinite_view_class
+        end
       end
     end
   end