linked_rails 0.0.1 → 0.0.4.pre.g0ec6e30ca

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

@@ -8,14 +8,15 @@ module LinkedRails
       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 :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 :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 +29,7 @@ module LinkedRails
       end
 
       def members
-        @members ||= raw_members
+        @members ||= include_members ? members_array : iris_from_members
       end
 
       def members_iri
@@ -42,9 +43,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 ? {members: {}, member_sequence: :members} : %i[member_sequence]
       end
 
       def title
@@ -62,6 +61,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?(members_query.klass)
+      end
+
+      def members_array
+        members_query.to_a
+      end
+
+      def polymorphic_collection?(klass)
+        column = klass.inheritance_column
+        polymorphic = klass.columns_hash.include?(column)
+        return false unless polymorphic
+
+        return true if klass.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 +101,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 +123,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

data/app/models/linked_rails/collection.rb

@@ -2,6 +2,7 @@
 
 require 'pundit'
 
+require_relative 'collection/configuration'
 require_relative 'collection/filter'
 require_relative 'collection/filterable'
 require_relative 'collection/iri'
@@ -9,28 +10,38 @@ require_relative 'collection/iri_mapping'
 require_relative 'collection/sortable'
 require_relative 'collection/sorting'
 require_relative 'collection/view'
+require_relative 'collection/paginated'
 require_relative 'collection/paginated_view'
+require_relative 'collection/infinite'
 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::Model::Actionable
+    include LinkedRails::Model::IRI
+    include LinkedRails::Collection::Configuration
     include LinkedRails::Collection::Filterable
-    include LinkedRails::Collection::Iri
-    include LinkedRails::Collection::IriMapping
+    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
+    attr_accessor :name, :policy, :user_context
+    attr_writer :association_base, :views
 
     alias id iri
 
+    def initialize(**opts)
+      opts = opts.with_indifferent_access
+
+      %i[association_class iri_template].each do |key|
+        raise("No #{key} given") if opts[key].blank?
+      end
+      opts[:route_key] ||= opts[:association_class].collection_route_key
+
+      super
+    end
+
     def action_list(user_context)
       @action_list ||= {}
       @action_list[user_context] ||= association_class.try(:action_list)&.new(
@@ -56,21 +67,8 @@ module LinkedRails
       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
+    def child_resource
+      @child_resource ||= build_child
     end
 
     def columns
@@ -79,18 +77,10 @@ module LinkedRails
       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
@@ -110,32 +100,7 @@ module LinkedRails
 
     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
-      )
+      self.class.new(**attrs)
     end
 
     def total_count
@@ -143,11 +108,7 @@ module LinkedRails
     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
+      (total_count / page_size.to_f).ceil if total_count
     end
 
     def unscoped_association
@@ -160,21 +121,25 @@ module LinkedRails
 
     def view_with_opts(opts)
       @views ||= []
-      view = LinkedRails.collection_view_class.new({collection: self, type: type}.merge(opts))
+      view = 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)
+    def build_child
+      child =
+        parent&.build_child(association_class, user_context: user_context) ||
+        association_class.build_new(parent: parent, user_context: user_context)
 
-      @default_display || association_class.try(:default_collection_display)
+      child.assign_attributes(association_base.where_values_hash) if association_base.respond_to?(:where_values_hash)
+      child.assign_attributes(permitted_attributes_from_filters(child))
+      child
     end
 
-    def default_type
-      @default_type || association_class.try(:default_collection_type) || :paginated
+    def collection_view_class
+      LinkedRails.collection_view_class
     end
 
     def default_view_opts
@@ -187,30 +152,33 @@ module LinkedRails
       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
+    def permitted_attributes_from_filters(child)
+      return {} if @filter.empty?
 
-      case display&.to_sym
-      when :table
-        :default
-      when :settingsTable
-        :settings
-      end
+      Pundit.policy(user_context, child).try(:permitted_attributes_from_filters, @filter) || {}
+    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 new_child_values
       instance_values
-        .slice('association', 'association_class', 'association_scope', 'iri_template', 'parent')
+        .slice(
+          'iri_template',
+          *LinkedRails::Model::Collections::COLLECTION_STATIC_OPTIONS.keys.map(&:to_s),
+          *LinkedRails::Model::Collections::COLLECTION_CUSTOMIZABLE_OPTIONS.keys.map { |key| "default_#{key}" }
+        )
         .merge(
           unfiltered_collection: filtered? ? @unfiltered_collection : self,
           user_context: user_context

data/app/models/linked_rails/creative_work.rb

@@ -8,7 +8,7 @@ module LinkedRails
     attr_writer :iri
     attr_accessor :description, :name, :text, :url
 
-    def iri(_opts = {})
+    def iri(**_opts)
       @iri ||= RDF::Node.new
     end
 

data/app/models/linked_rails/entry_point.rb

@@ -6,7 +6,7 @@ module LinkedRails
     include LinkedRails::Model
 
     attr_accessor :parent
-    attr_writer :url
+    attr_writer :target_url
     delegate :form, :description, :http_method, :image, :user_context,
              :resource, :tag, to: :parent
 
@@ -16,12 +16,15 @@ module LinkedRails
       form&.form_iri
     end
 
-    def as_json(_opts = {})
+    def as_json(**_opts)
       {}
     end
 
     def iri_template
-      @iri_template ||= iri_template_with_fragment(URITemplate.new(parent.root_relative_iri.to_s), :EntryPoint)
+      @iri_template ||= iri_template_with_fragment(
+        LinkedRails::URITemplate.new(parent.root_relative_iri.to_s),
+        :EntryPoint
+      )
     end
 
     def label
@@ -30,8 +33,8 @@ module LinkedRails
       value || label_fallback
     end
 
-    def url
-      @url || parent.url
+    def target_url
+      @target_url || parent.target_url
     end
 
     private

data/app/models/linked_rails/enum_value.rb

@@ -5,14 +5,14 @@ module LinkedRails
     include ActiveModel::Model
     include LinkedRails::Model
 
-    attr_accessor :attr, :close_match, :exact_match, :group_by, :key, :klass, :type
+    attr_accessor :attr, :close_match, :exact_match, :group_by, :identifier, :key, :klass, :type
     attr_writer :iri, :label
 
     def label
       label_from_variable || LinkedRails.translate(:enum, :label, self)
     end
 
-    def iri(_opts = {})
+    def iri(**_opts)
       @iri || iri_with_root(RDF::URI("/enums/#{klass.name.tableize}/#{attr}##{key}"))
     end
 
@@ -29,5 +29,43 @@ module LinkedRails
     def label_from_variable
       @label.respond_to?(:call) ? @label.call : @label
     end
+
+    class << self
+      def class_for_params(params)
+        LinkedRails.linked_models.detect do |klass|
+          klass.to_s == ([params[:module]].compact + [params[:klass]&.singularize]).join('/').classify
+        end
+      end
+
+      def enum_options(params)
+        serializer_for_params(params)&.enum_options(params[:attribute])
+      end
+
+      def requested_resource(opts, _user_context)
+        options = enum_options(opts[:params])
+
+        return unless options
+
+        LinkedRails::Sequence.new(
+          options.values,
+          id: sanitized_sequence_iri(opts[:iri]),
+          scope: LinkedRails::EnumValuePolicy::Scope
+        )
+      end
+
+      def sanitized_sequence_iri(raw_iri)
+        iri = RDF::URI(raw_iri)
+        iri.query = nil
+        iri.fragment = nil
+        iri.path = iri.path.split('.').first
+        iri
+      end
+
+      def serializer_for_params(params)
+        klass = class_for_params(params)
+
+        RDF::Serializers.serializer_for(klass) if klass
+      end
+    end
   end
 end

data/app/models/linked_rails/form/field/association_input.rb

@@ -9,7 +9,13 @@ module LinkedRails
         def datatype; end
 
         def nested_form
-          @nested_form ||= klass_name.constantize.form_class
+          @nested_form ||= target_class.form_class
+        end
+
+        def target_class
+          return @target_class if @target_class
+
+          klass_name.constantize unless form.abstract_form
         end
 
         private

data/app/models/linked_rails/form/field/file_input.rb

@@ -4,6 +4,11 @@ module LinkedRails
   class Form
     class Field
       class FileInput < Field
+        attr_writer :max_size
+
+        def max_size
+          @max_size.respond_to?(:call) ? @max_size.call : @max_size
+        end
       end
     end
   end

data/app/models/linked_rails/form/field/resource_field.rb

@@ -10,6 +10,8 @@ module LinkedRails
 
         attr_reader :path
 
+        def label_from_property; end
+
         def permission_required?
           false
         end

data/{lib/linked_rails/enhancements/indexable/model.rb → app/models/linked_rails/form/field/url_input.rb}

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
 
 module LinkedRails
-  module Enhancements
-    module Indexable
-      module Model
+  class Form
+    class Field
+      class UrlInput < Field
       end
     end
   end

data/app/models/linked_rails/form/field.rb

@@ -2,25 +2,27 @@
 
 module LinkedRails
   class Form
-    class Field < LinkedRails::Resource
-      attr_writer :datatype,
-                  :description,
+    class Field < LinkedRails::Resource # rubocop:disable Metrics/ClassLength
+      attr_writer :description,
                   :helper_text,
                   :label,
+                  :max_inclusive,
                   :max_length,
                   :min_count,
+                  :min_inclusive,
                   :min_length,
-                  :sh_in,
                   :pattern,
-                  :path
-      attr_accessor :default_value,
+                  :path,
+                  :placeholder,
+                  :sh_in,
+                  :start_adornment
+      attr_accessor :datatype,
+                    :default_value,
                     :max_count,
                     :max_count_prop,
-                    :max_inclusive,
                     :max_inclusive_prop,
                     :max_length_prop,
                     :min_count_prop,
-                    :min_inclusive,
                     :min_inclusive_prop,
                     :min_length_prop,
                     :model_attribute,
@@ -31,9 +33,6 @@ module LinkedRails
                     :validators,
                     :sh_in_prop,
                     :key
-      def datatype
-        @datatype || raise("No datatype found for #{key} in #{form.name}")
-      end
 
       def description
         description_from_attribute || description_fallback
@@ -43,6 +42,10 @@ module LinkedRails
         helper_text_from_attribute || helper_text_fallback
       end
 
+      def max_inclusive
+        @max_inclusive || validators[:max_inclusive]
+      end
+
       def max_length
         @max_length || validators[:max_length]
       end
@@ -51,6 +54,10 @@ module LinkedRails
         @min_count || (validators[:presence] ? 1 : nil)
       end
 
+      def min_inclusive
+        @min_inclusive || validators[:min_inclusive]
+      end
+
       def min_length
         @min_length || validators[:min_length]
       end
@@ -72,12 +79,20 @@ module LinkedRails
         true
       end
 
+      def placeholder
+        placeholder_from_attribute || placeholder_fallback
+      end
+
       def sh_in
         return validators[:sh_in] if @sh_in.blank?
 
         @sh_in.respond_to?(:call) ? @sh_in.call : @sh_in
       end
 
+      def start_adornment
+        @start_adornment.respond_to?(:call) ? @start_adornment.call : @start_adornment
+      end
+
       private
 
       def description_from_attribute
@@ -101,12 +116,21 @@ module LinkedRails
       end
 
       def label_fallback
-        field_label = LinkedRails.translate(:field, :label, self, false)
-        return field_label if field_label.present?
+        LinkedRails.translate(:field, :label, self, false).presence || label_from_property
+      end
 
+      def label_from_property
         LinkedRails.translate(:property, :label, path) if path
       end
 
+      def placeholder_from_attribute
+        @placeholder.respond_to?(:call) ? @placeholder.call : @placeholder
+      end
+
+      def placeholder_fallback
+        LinkedRails.translate(:field, :placeholder, self, false)
+      end
+
       class << self
         def iri
           Vocab.form[name.demodulize]