linked_rails 0.0.3 → 0.0.4

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

@@ -3,54 +3,21 @@
 module LinkedRails
   class Collection
     module Iri
-      extend ActiveSupport::Concern
+      DEFAULT_IRI_TEMPLATE_KEYS = %i[before%5B%5D display filter%5B%5D page page_size sort%5B%5D 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('')
-          )
-      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]}" }
+        {
+          parent_iri: parent_iri,
+          display: @display,
+          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
 
       class_methods do
@@ -58,15 +25,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

@@ -7,9 +7,9 @@ module LinkedRails
 
       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,45 @@
+# 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
+        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

@@ -14,8 +14,8 @@ module LinkedRails
 
       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
@@ -78,15 +78,15 @@ module LinkedRails
           [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 +95,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::Actionable
     include LinkedRails::Model::Iri
+    include LinkedRails::Collection::Configuration
     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
+    attr_accessor :name, :policy, :user_context, :view
+    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,18 +67,14 @@ 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))
+      parser = LinkedRails::ParamsParser.new(user_context: user_context, params: {filter: @filter})
       permitted_child_keys = Pundit.policy(user_context, child)&.permitted_attributes || []
-      permitted_attributes_from_filters = attributes_from_filters.permit(permitted_child_keys)
+      permitted_attributes_from_filters = parser.attributes_from_filters(association_class).permit(permitted_child_keys)
 
       child.assign_attributes(permitted_attributes_from_filters)
       child
@@ -79,18 +86,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,7 +109,7 @@ module LinkedRails
 
     def new_child(options)
       attrs = options.merge(new_child_values)
-      self.class.new(attrs)
+      self.class.new(**attrs)
     end
 
     def preview_includes
@@ -122,32 +121,12 @@ module LinkedRails
       }
     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
+      (total_count / page_size.to_f).ceil if total_count
     end
 
     def unscoped_association
@@ -160,21 +139,15 @@ 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)
-
-      @default_display || association_class.try(:default_collection_display)
-    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 +160,23 @@ 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 title_from_translation
+      plural = association_class.name.tableize
 
-      case display&.to_sym
-      when :table
-        :default
-      when :settingsTable
-        :settings
-      end
+      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))
         .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

@@ -12,7 +12,7 @@ module LinkedRails
       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/resource_field.rb

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

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

@@ -3,8 +3,7 @@
 module LinkedRails
   class Form
     class Field < LinkedRails::Resource
-      attr_writer :datatype,
-                  :description,
+      attr_writer :description,
                   :helper_text,
                   :label,
                   :max_length,
@@ -13,7 +12,8 @@ module LinkedRails
                   :sh_in,
                   :pattern,
                   :path
-      attr_accessor :default_value,
+      attr_accessor :datatype,
+                    :default_value,
                     :max_count,
                     :max_count_prop,
                     :max_inclusive,
@@ -31,9 +31,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
@@ -101,9 +98,10 @@ 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