linked_rails 0.0.1

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

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module LinkedRails
+  class Collection
+    class Filter < RDF::Node
+      include ActiveModel::Model
+      include LinkedRails::Model
+
+      attr_accessor :default_filter, :key, :value, :collection
+
+      def iri(_opts = {})
+        self
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module LinkedRails
+  class Collection
+    class FilterField < RDF::Node
+      include ActiveModel::Serialization
+      include ActiveModel::Model
+      include LinkedRails::Model
+      include LinkedRails::CallableVariable
+
+      attr_accessor :key, :klass, :collection
+      attr_writer :options_array, :options_in
+      callable_variable(:options_array)
+      callable_variable(:options_in)
+
+      def iri(_opts = {})
+        self
+      end
+
+      def options
+        @options ||= options_array&.map(&method(:filter_option)) || []
+      end
+
+      def filter_option(option)
+        attrs = option.is_a?(Hash) ? option : {value: option}
+        Collection::FilterOption.new(attrs.merge(collection: collection, key: key))
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module LinkedRails
+  class Collection
+    class FilterOption < RDF::Node
+      include ActiveModel::Serialization
+      include ActiveModel::Model
+      include LinkedRails::Model
+
+      attr_accessor :collection, :count, :value, :key
+
+      def iri(_opts = {})
+        self
+      end
+    end
+  end
+end

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

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module LinkedRails
+  class Collection
+    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
+
+      def filter
+        default_filters.merge(@filter || {})
+      end
+
+      delegate :filter_options, to: :association_class
+
+      def filter_fields
+        @filter_fields ||= filter_options&.map { |key, options| filter_field(key, options) }
+      end
+
+      def filtered?
+        filter.present?
+      end
+
+      def filters
+        @filters ||= filter.map do |key, values|
+          predicate = key.is_a?(RDF::URI) ? key : association_class.predicate_for_key(key)
+
+          LinkedRails.collection_filter_class.new(
+            collection: self,
+            default_filter: !@filter&.key?(predicate),
+            key: predicate,
+            value: values.map { |val| sanitized_filter_value(predicate, val) }
+          )
+        end
+      end
+
+      def unfiltered
+        filtered? ? unfiltered_collection : self
+      end
+
+      def unfiltered_collection
+        @unfiltered_collection ||= new_child(filter: {})
+      end
+
+      private
+
+      def apply_filters(scope)
+        (filters || []).reduce(scope) do |s, filter|
+          apply_filter(s, filter.key, filter.value)
+        end
+      end
+
+      def apply_filter(scope, key, values)
+        filter = filter_options.fetch(key).try(:[], :filter)
+
+        return filter.call(scope, values) if filter
+
+        scope.where(association_class.predicate_mapping[key].key => values)
+      end
+
+      def filtered_association # rubocop:disable Metrics/AbcSize
+        scope = association && parent&.send(association) || association_class.all
+        scope = scope.send(association_scope) if association_scope
+        scope = scope.joins(joins) if joins
+        scope = apply_filters(scope) if filtered?
+        scope
+      end
+
+      def filter_field(key, options)
+        Collection::FilterField.new(
+          collection: self,
+          klass: association_class,
+          key: key,
+          options_in: options[:values_in],
+          options_array: options[:values]
+        )
+      end
+
+      def sanitized_filter_value(key, value)
+        mapping = association_class.predicate_mapping[key]
+        datatype = mapping.is_a?(FastJsonapi::Relationship) ? RDF.xsd.anyURI : mapping.datatype
+        val = xsd_to_rdf(datatype, value)
+        val.literal? ? val.object : val
+      end
+    end
+  end
+end

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

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+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
+    end
+  end
+end

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

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module LinkedRails
+  class Collection
+    module Iri
+      extend ActiveSupport::Concern
+
+      included do
+        attr_writer :iri_template
+      end
+
+      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('')
+          )
+      end
+
+      def iri_template_opts
+        opts = iri_opts.with_indifferent_access.slice(*self.class.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
+      end
+
+      def iri_opts_add(opts, key, value)
+        opts[key] = value if value.present?
+      end
+
+      def sort_iri_opts
+        sort&.map { |s| "#{CGI.escape(s[:key].to_s)}=#{s[:direction]}" }
+      end
+
+      class_methods do
+        def iri
+          [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]
+        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(',')
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module LinkedRails
+  class Collection
+    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)
+
+          view_params.present? ? collection&.view_with_opts(view_params) : collection
+        end
+
+        private
+
+        def collection_params(parser)
+          parser.collection_params
+        end
+
+        def collection_view_params(parser)
+          parser.collection_view_params
+        end
+
+        def params_parser_class
+          LinkedRails::ParamsParser
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+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
+    end
+  end
+end

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

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module LinkedRails
+  class Collection
+    module Sortable
+      attr_accessor :sort
+      attr_writer :default_sortings, :sort_options
+
+      def default_before_value
+        sortings.map do |sorting|
+          {
+            key: sorting.key,
+            value: sorting.default_value
+          }
+        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
+
+      def primary_key_sorting
+        [
+          {
+            key: Vocab.ontola[:primaryKey],
+            direction: :asc
+          }
+        ]
+      end
+
+      def sort_options
+        @sort_options || association_class.try(:sort_options, self)
+      end
+
+      def sorted_association(scope)
+        scope.respond_to?(:reorder) ? scope.reorder(parsed_sort_values) : scope
+      end
+
+      def sorted?
+        sort.present?
+      end
+
+      def sortings
+        @sortings ||= LinkedRails.collection_sorting_class.from_array(
+          association_class,
+          (sort || default_sortings) + primary_key_sorting,
+          self
+        )
+      end
+    end
+  end
+end