linked_rails 0.0.1

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

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module LinkedRails
+  class Collection
+    class Sorting < RDF::Node
+      include ActiveModel::Model
+      include LinkedRails::Model
+      DATE_MIN = Date.new(1970, 1, 1)
+      DATE_TIME_MIN = Time.new(1970, 1, 1).utc
+      STRING_MIN = ('0'.ord - 1).chr
+      STRING_MAX = ('z'.ord + 1).chr
+
+      attr_accessor :association_class, :direction, :key, :collection
+
+      def attribute_name
+        @attribute_name ||= key_from_mapping || :created_at
+      end
+
+      # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength
+      def default_value
+        column = association_class.column_for_attribute(attribute_name)
+
+        case column.type
+        when :date
+          direction == :asc ? DATE_MIN : Date.current
+        when :datetime
+          (direction == :asc ? DATE_TIME_MIN : Time.current.utc).iso8601(6)
+        when :string, :text
+          direction == :asc ? STRING_MIN : STRING_MAX
+        else
+          ActiveModel::Type::Integer.new(limit: column.limit).send(direction == :asc ? :min_value : :max_value)
+        end
+      end
+      # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength
+
+      def iri(_opts = {})
+        self
+      end
+
+      def sort_direction
+        direction == :desc ? :lt : :gt
+      end
+
+      def sort_value
+        {attribute_name => direction}
+      end
+
+      private
+
+      def key_from_mapping
+        if key == Vocab.ontola[:primaryKey]
+          association_class.try(:primary_key)
+        else
+          association_class.try(:predicate_mapping).try(:[], key)&.key
+        end
+      end
+
+      class << self
+        def from_array(association_class, array, collection)
+          array&.map do |sort|
+            new(
+              collection: collection,
+              association_class: association_class,
+              direction: sort[:direction]&.to_sym,
+              key: sort[:key]
+            )
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module LinkedRails
+  class Collection
+    class View
+      include ActiveModel::Model
+
+      include LinkedRails::Model
+
+      attr_accessor :collection, :filter
+      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
+
+      def root_relative_iri(opts = {})
+        collection.unfiltered.root_relative_iri(iri_opts.merge(opts))
+      end
+
+      def member_sequence
+        @member_sequence ||= LinkedRails::Sequence.new(
+          members,
+          id: members_iri,
+          parent: self,
+          scope: false
+        )
+      end
+
+      def members
+        @members ||= raw_members
+      end
+
+      def members_iri
+        uri = iri.dup
+        uri.fragment = :members
+        uri
+      end
+
+      def page_size
+        collection.page_size&.to_i || default_page_size
+      end
+
+      def preview_includes
+        return {member_sequence: {}} unless association_class.include_in_collection?
+
+        {member_sequence: {members: association_class.preview_includes}}
+      end
+
+      def title
+        plural = association_class.name.tableize
+        I18n.t(
+          "#{plural}.collection.#{filter&.values&.join('.').presence || name}",
+          count: ->(_opts) { total_count },
+          default: association_class.plural_label
+        )
+      end
+
+      private
+
+      def arel_table
+        @arel_table ||= association_class.arel_table
+      end
+
+      def prepare_members(scope)
+        if scope.respond_to?(:preload) && association_class.try(:includes_for_serializer)
+          scope = scope.preload(association_class.includes_for_serializer)
+        end
+        scope
+      end
+
+      def raw_members
+        @raw_members ||= members_query.to_a
+      end
+
+      class << self
+        def iri
+          [super, Vocab.as.CollectionPage]
+        end
+
+        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)
+          when :infinite
+            LinkedRails.collection_infinite_view_class.new(opts)
+          else
+            raise ActionController::BadRequest, "'#{type}' is not a valid collection type"
+          end
+        end
+
+        def policy_class
+          LinkedRails::Collection::ViewPolicy
+        end
+      end
+    end
+  end
+end

data/app/models/linked_rails/collection.rb

@@ -0,0 +1,220 @@
+# frozen_string_literal: true
+
+require 'pundit'
+
+require_relative 'collection/filter'
+require_relative 'collection/filterable'
+require_relative 'collection/iri'
+require_relative 'collection/iri_mapping'
+require_relative 'collection/sortable'
+require_relative 'collection/sorting'
+require_relative 'collection/view'
+require_relative 'collection/paginated_view'
+require_relative 'collection/infinite_view'
+
+module LinkedRails
+  class Collection # rubocop:disable Metrics/ClassLength
+    include ActiveModel::Model
+    include LinkedRails::Model::Enhancements
+    include LinkedRails::Model::Iri
+    include LinkedRails::Collection::Filterable
+    include LinkedRails::Collection::Iri
+    include LinkedRails::Collection::IriMapping
+    include LinkedRails::Collection::Sortable
+
+    enhance LinkedRails::Enhancements::Actionable
+
+    attr_accessor :association, :association_class, :association_scope, :grid_max_columns, :joins,
+                  :name, :page_size, :parent, :part_of, :policy, :user_context, :view
+    attr_writer :association_base, :table_type, :default_display, :default_title, :default_type,
+                :display, :policy_scope, :title, :type, :views
+
+    alias id iri
+
+    def action_list(user_context)
+      @action_list ||= {}
+      @action_list[user_context] ||= association_class.try(:action_list)&.new(
+        resource: self,
+        user_context: user_context
+      )
+    end
+
+    def actions(user_context = nil)
+      return [] if action_list(user_context).nil?
+
+      super
+    end
+
+    def apply_scope(association)
+      return association if policy_scope == false
+
+      policy_scope.new(user_context, association).resolve
+    end
+
+    # prevents a `stack level too deep`
+    def as_json(options = {})
+      super(options.merge(except: %w[association_class unfiltered_collection collection]))
+    end
+
+    def association_base
+      @association_base ||= apply_scope(sorted_association(filtered_association))
+    end
+
+    def build_child # rubocop:disable Metrics/AbcSize
+      child =
+        parent&.build_child(association_class, user_context: user_context) ||
+        association_class.build_new(parent: parent, user_context: user_context)
+
+      attributes_from_filters = ActionController::Parameters.new(association_class.attributes_from_filters(@filter))
+      permitted_child_keys = Pundit.policy(user_context, child)&.permitted_attributes || []
+      permitted_attributes_from_filters = attributes_from_filters.permit(permitted_child_keys)
+
+      child.assign_attributes(permitted_attributes_from_filters)
+      child
+    end
+
+    def columns
+      columns_list = association_class.try(:defined_columns).try(:[], table_type)
+
+      RDF::List[*columns_list] if columns_list.present?
+    end
+
+    def default_page_size
+      association_class.try(:default_per_page) || 20
+    end
+
+    def default_view
+      @default_view ||= view_with_opts(default_view_opts)
+    end
+
+    def display
+      @display&.to_sym || default_display
+    end
+
+    def first
+      case type
+      when :paginated
+        iri_with_root(root_relative_iri(page: 1))
+      when :infinite
+        iri_with_root(root_relative_iri(before: default_before_value))
+      end
+    end
+
+    def inspect
+      "#<#{association_class}Collection iri:#{iri}>"
+    end
+
+    def last
+      iri_with_root(root_relative_iri(page: [total_page_count, 1].max)) if type == :paginated && total_page_count
+    end
+
+    def new_child(options)
+      attrs = options.merge(new_child_values)
+      self.class.new(attrs)
+    end
+
+    def preview_includes
+      {
+        default_view: default_view.preview_includes,
+        filter_fields: :options,
+        filters: [],
+        sortings: []
+      }
+    end
+
+    def title
+      var = @title || @default_title
+      return var.call(parent) if var.respond_to?(:call)
+
+      var || title_from_translation
+    end
+
+    def title_from_translation
+      plural = association_class.name.tableize
+      I18n.t(
+        "#{plural}.collection.#{@filter&.values&.join('.').presence || name || :default}",
+        count: ->(_opts) { total_count },
+        default: association_class.plural_label
+      )
+    end
+
+    def total_count
+      @total_count ||= association_base.try(:total_count) || unscoped_association.count
+    end
+
+    def total_page_count
+      (total_count / (page_size || default_page_size).to_f).ceil if total_count
+    end
+
+    def type
+      @type&.to_sym || default_type
+    end
+
+    def unscoped_association
+      association_base.respond_to?(:unscope) ? association_base.unscope(:select) : association_base
+    end
+
+    def views
+      @views || [default_view]
+    end
+
+    def view_with_opts(opts)
+      @views ||= []
+      view = LinkedRails.collection_view_class.new({collection: self, type: type}.merge(opts))
+      @views << view
+      view
+    end
+
+    private
+
+    def default_display
+      @default_display = @default_display.call(parent) if @default_display.respond_to?(:call)
+
+      @default_display || association_class.try(:default_collection_display)
+    end
+
+    def default_type
+      @default_type || association_class.try(:default_collection_type) || :paginated
+    end
+
+    def default_view_opts
+      opts = {
+        type: type,
+        filter: filter
+      }
+      opts[:page] = 1 if type == :paginated
+      opts[:before] = default_before_value if type == :infinite
+      opts
+    end
+
+    def policy_scope
+      return @policy_scope if @policy_scope == false
+
+      @policy_scope = policy ? policy::Scope : Pundit::PolicyFinder.new(filtered_association).scope!
+    end
+
+    def paginated?
+      type == :paginated
+    end
+
+    def table_type
+      return @table_type if @table_type
+
+      case display&.to_sym
+      when :table
+        :default
+      when :settingsTable
+        :settings
+      end
+    end
+
+    def new_child_values
+      instance_values
+        .slice('association', 'association_class', 'association_scope', 'iri_template', 'parent')
+        .merge(
+          unfiltered_collection: filtered? ? @unfiltered_collection : self,
+          user_context: user_context
+        )
+    end
+  end
+end

data/app/models/linked_rails/condition.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module LinkedRails
+  class Condition < LinkedRails::Resource
+    attr_accessor :fail, :shape, :pass
+  end
+end

data/app/models/linked_rails/creative_work.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module LinkedRails
+  class CreativeWork
+    include ActiveModel::Model
+    include LinkedRails::Model
+
+    attr_writer :iri
+    attr_accessor :description, :name, :text, :url
+
+    def iri(_opts = {})
+      @iri ||= RDF::Node.new
+    end
+
+    class << self
+      def iri
+        Vocab.schema.CreativeWork
+      end
+    end
+  end
+end

data/app/models/linked_rails/current_user.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module LinkedRails
+  class CurrentUser
+    include ActiveModel::Model
+    include LinkedRails::Model
+
+    attr_accessor :user
+
+    def actor_type
+      if user.is_a?(LinkedRails.guest_user_class)
+        'GuestUser'
+      else
+        'ConfirmedUser'
+      end
+    end
+
+    def rdf_type
+      Vocab.ontola[actor_type]
+    end
+
+    class << self
+      def route_key
+        :c_a
+      end
+    end
+  end
+end