linked_rails 0.0.1 → 0.0.4.pre.g1faca9643

data/lib/linked_rails/model/collections.rb

@@ -5,8 +5,181 @@ module LinkedRails
     module Collections
       extend ActiveSupport::Concern
 
+      COLLECTION_CUSTOMIZABLE_OPTIONS = {
+        # display [Sym] The default display type.
+        #   Choose between :grid, :settingsTable, :table, :card, :default
+        display: :default,
+        # grid_max_columns [Integer] The default amount of columns to use in a grid.
+        grid_max_columns: 3,
+        # page_size [Integer] The default page size.
+        page_size: 20,
+        # table_type [Sym] The columns to use in the table.
+        table_type: lambda {
+          case display&.to_sym
+          when :table
+            :default
+          when :settingsTable
+            :settings
+          end
+        },
+        # title String The default title.
+        title: -> { title_from_translation },
+        # type [Sym] The default pagination type.
+        #   Choose between :paginated, :infinite.
+        type: :paginated
+      }.freeze
+      COLLECTION_STATIC_OPTIONS = {
+        # association [Sym] The association of the collection items.
+        association: nil,
+        # association_base [Scope, Array] The items of the collection.
+        association_base: -> { apply_scope(sorted_association(filtered_association)) },
+        # association_class [Class] The class of the collection items.
+        association_class: nil,
+        # association_scope [Sym] The scope applied to the collection.
+        association_scope: nil,
+        # call_to_action [String] The label shown as call to action.
+        call_to_action: nil,
+        # collection_class [Class] The base class of the collection.
+        #   If you want to use a class other than LinkedRails.collection_class.
+        collection_class: nil,
+        # collection_class [Hash] The default filters applied to the collection.
+        default_filters: {},
+        # collection_class [Array<Hash>] The default sortings applied to the collection.
+        default_sortings: [{key: Vocab.schema.dateCreated, direction: :desc}],
+        # include_members [Boolean] Whether to include the members of this collection.
+        include_members: false,
+        # iri_template_keys [Array<Sym>] Custom query keys for the iri template
+        iri_template_keys: [],
+        # joins [Array<Sym>, Sym] The associations to join
+        joins: nil,
+        # parent [Instance] The default parent of a collection.
+        parent: nil,
+        # parent_iri [Array<String>] The iri elements of the parent
+        parent_iri: -> { parent&.iri_elements },
+        # part_of [Instance] The record to serialize as isPartOf
+        part_of: -> { parent },
+        # policy_scope [Scope] The policy scope class to be used for scoping
+        #   Set to false to skip scoping
+        policy_scope: -> { policy ? policy::Scope : Pundit::PolicyFinder.new(filtered_association).scope! },
+        # route_key [Symbol, String] The route key for the association
+        route_key: nil,
+        # view [IRI] The view to use for rendering the members
+        view: nil
+      }.freeze
+      COLLECTION_OPTIONS = COLLECTION_CUSTOMIZABLE_OPTIONS.merge(COLLECTION_STATIC_OPTIONS)
+
+      module ClassMethods
+        def collection_iri(**opts)
+          LinkedRails.iri(path: collection_root_relative_iri(**opts))
+        end
+
+        # Sets the defaults for all collections for this class.
+        # Can be overridden by #with_collection, called from associated models,
+        # or by passing parameters in an iri.
+        # @param [Hash] options
+        def collection_options(**options)
+          initialize_default_collection_opts
+
+          options.each do |key, value|
+            raise("Invalid key passed to collection_options: #{key}") unless valid_collection_option?(key)
+
+            _default_collection_opts[key] = value
+          end
+          _default_collection_opts[:iri_template] = _default_collection_opts[:collection_class].generate_iri_template(
+            _default_collection_opts[:iri_template_keys]
+          )
+          _default_collection_opts
+        end
+
+        def collection_root_relative_iri(**opts)
+          opts[:filter] = LinkedRails.collection_class.filter_iri_opts(opts[:filter]) if opts.key?(:filter)
+          opts[:route_key] = collection_route_key
+          default_collection_option(:iri_template).expand(**opts)
+        end
+
+        def collection_route_key
+          default_collection_option(:route_key) || route_key
+        end
+
+        def default_collection_options
+          initialize_default_collection_opts
+
+          _default_collection_opts
+        end
+
+        def default_collection_option(key)
+          default_collection_options[key]
+        end
+
+        # Defines a collection to be used in {collection_for}
+        # @see Ldable#collection_for
+        # @note Adds a instance_method <name>_collection
+        # @param [Hash] name as to be used in {collection_for}
+        # @param [Hash] options See COLLECTION_OPTIONS
+        # @return [Collection]
+        def with_collection(name, **options) # rubocop:disable Metrics/AbcSize
+          options[:association] ||= name.to_sym
+          options[:association_class] ||= name.to_s.classify.constantize
+          merged_options = options[:association_class].default_collection_options.merge(options)
+          merged_options[:iri_template] = merged_options[:collection_class].generate_iri_template(
+            merged_options[:iri_template_keys]
+          )
+          collections_add(name: name, options: merged_options)
+
+          define_method "#{name.to_s.singularize}_collection" do |opts = {}|
+            collection_for(name, **opts)
+          end
+        end
+
+        private
+
+        def collections_add(opts)
+          initialize_collections
+          collections.delete_if { |c| c[:name] == opts[:name] }
+          opts[:options] = sanitized_collection_options(opts[:options])
+          collections.append(opts)
+        end
+
+        def initialize_collections
+          return if collections && method(:collections).owner == singleton_class
+
+          self.collections = superclass.try(:collections)&.dup || []
+        end
+
+        def initialize_default_collection_opts # rubocop:disable Metrics/AbcSize
+          return if _default_collection_opts && method(:_default_collection_opts).owner == singleton_class
+
+          self._default_collection_opts = (superclass.try(:_default_collection_opts) || COLLECTION_OPTIONS).dup
+
+          _default_collection_opts[:collection_class] ||= LinkedRails.collection_class
+          _default_collection_opts[:association_class] = self
+          _default_collection_opts[:iri_template] = _default_collection_opts[:collection_class].generate_iri_template(
+            _default_collection_opts[:iri_template_keys]
+          )
+
+          _default_collection_opts
+        end
+
+        def sanitized_collection_options(opts)
+          opts.each_with_object(HashWithIndifferentAccess.new) do |(key, value), hash|
+            raise("Invalid key passed to with_collection: #{key}") unless valid_collection_option?(key.to_sym)
+
+            hash_key = COLLECTION_CUSTOMIZABLE_OPTIONS.key?(key.to_sym) ? "default_#{key}" : key
+
+            hash[hash_key] = value
+          end
+        end
+
+        def valid_collection_option?(key)
+          COLLECTION_OPTIONS.key?(key) || key == :iri_template
+        end
+      end
+
       included do
         class_attribute :collections
+        class_attribute :_default_collection_opts,
+                        instance_accessor: false,
+                        instance_predicate: false
       end
 
       # Initialises a {Collection} for one of the collections defined by {has_collection}
@@ -18,19 +191,42 @@ module LinkedRails
       # @param [ApplicationRecord] part_of
       # @param [Hash] opts Additional options to be passed to the collection.
       # @return [Collection]
-      def collection_for(name, instance_opts = {})
-        collection_opts = collections.detect { |c| c[:name] == name }.try(:[], :options).dup
+      def collection_for(name, **instance_opts)
+        collection_opts = collection_options_for(name).dup
         return if collection_opts.blank?
 
         collection_opts[:name] = name
         collection_opts[:parent] = self
-        collection_opts[:part_of] = collection_opts.key?(:part_of) ? send(collection_opts[:part_of]) : self
-        collection_class = collection_opts.delete(:collection_class) || LinkedRails.collection_class
+        collection_class =
+          collection_opts.delete(:collection_class) ||
+          collection_opts[:association_class].default_collection_option(:collection_class) ||
+          LinkedRails.collection_class
         collection_class.collection_or_view(collection_opts, instance_opts)
       end
 
+      def collection_iri(collection, **opts)
+        LinkedRails.iri(path: collection_root_relative_iri(collection, **opts))
+      end
+
+      def collection_options_for(name)
+        opts = collections.detect { |c| c[:name] == name.to_sym }
+        raise("Collection #{name} not found for #{self}") unless opts
+
+        opts[:options] || {}
+      end
+
+      def collection_root_relative_iri(collection, **opts)
+        collection_opts = collection_options_for(collection).dup
+        template = collection_opts[:iri_template]
+        klass = collection_opts[:association_class]
+        opts[:route_key] = collection_opts[:route_key] || klass.collection_route_key
+        opts[:parent_iri] = iri_elements
+
+        template.expand(**opts).to_s
+      end
+
       def parent_collections(user_context)
-        return [] if try(:parent).try(:collections).blank?
+        return [self.class.root_collection(user_context: user_context)] if try(:parent).try(:collections).blank?
 
         parent_collections_for(parent, user_context)
       end
@@ -43,40 +239,6 @@ module LinkedRails
           .select { |collection| is_a?(collection[:options][:association_class]) }
           .map { |collection| parent.collection_for(collection[:name], user_context: user_context) }
       end
-
-      module ClassMethods
-        def collections_add(opts)
-          initialize_collections
-          collections.delete_if { |c| c[:name] == opts[:name] }
-          collections.append(opts)
-        end
-
-        def initialize_collections
-          return if collections && method(:collections).owner == singleton_class
-
-          self.collections = superclass.try(:collections)&.dup || []
-        end
-
-        # Defines a collection to be used in {collection_for}
-        # @see Ldable#collection_for
-        # @note Adds a instance_method <name>_collection
-        # @param [Hash] name as to be used in {collection_for}
-        # @param [Hash] options
-        # @option options [Sym] association the name of the association
-        # @option options [Class] association_class the class of the association
-        # @option options [Sym] joins the associations to join
-        # @return [Collection]
-        def with_collection(name, options = {})
-          options[:association] ||= name.to_sym
-          options[:association_class] ||= name.to_s.classify.constantize
-
-          collections_add(name: name, options: options)
-
-          define_method "#{name.to_s.singularize}_collection" do |opts = {}|
-            collection_for(name, opts)
-          end
-        end
-      end
     end
   end
 end

data/lib/linked_rails/model/dirty.rb

@@ -22,40 +22,28 @@ module LinkedRails
         end
       end
 
-      def previous_changes_by_predicate
-        serializer_class = RDF::Serializers.serializer_for(self)
-        return {} unless respond_to?(:previous_changes) && serializer_class
-
-        Hash[
-          previous_changes
-            .map { |k, v| [serializer_class.attributes_to_serialize[k.to_sym]&.predicate, v] }
-            .select { |k, _v| k.present? }
-        ]
-      end
-
-      def previously_changed_relations
+      def previously_changed_relations(inverted = nil)
         serializer_class = RDF::Serializers.serializer_for(self)
         return {} unless serializer_class.try(:relationships_to_serialize)
 
         serializer_class.relationships_to_serialize.select do |key, _value|
           if respond_to?(key)
             association_key = key.to_s.ends_with?('_collection') ? send(key).association : key
-            association_has_destructed?(association_key) || association_changed?(association_key)
+            association_has_destructed?(association_key) || association_changed?(association_key, inverted)
           end
         end.with_indifferent_access
       end
 
       private
 
-      def association_changed?(association) # rubocop:disable Metrics/AbcSize
+      def association_changed?(association, inverted) # rubocop:disable Metrics/AbcSize
         ids_method = "#{association.to_s.singularize}_ids"
         return true if previous_changes.include?("#{association}_id") || previous_changes.include?(ids_method)
         return false unless try(:association_cached?, association)
+        records = self.class.reflect_on_association(association).collection? ? send(association) : [send(association)]
 
-        if self.class.reflect_on_association(association).collection?
-          send(association).any? { |a| a.previous_changes.present? }
-        else
-          send(association)&.previous_changes&.present?
+        records.reject { |a| a == inverted }.any? do |a|
+          a&.previous_changes.present? || a&.previously_changed_relations(self).present?
         end
       end
 

data/lib/linked_rails/model/enhancements.rb

@@ -16,14 +16,13 @@ module LinkedRails
 
       module ClassMethods
         # Adds an enhancement to a model and includes the Model module.
-        def enhance(enhancement, opts = {})
+        def enhance(enhancement, **opts)
           initialize_enhancements
           already_included = enhanced_with?(enhancement)
 
           self.enhancements[enhancement] = opts
           return if already_included
 
-          enhance_routing(enhancement) if enhancement.const_defined?(:Routing) && enhanced_with?(enhancement, :Routing)
           include enhancement::Model if enhancement.const_defined?(:Model) && enhanced_with?(enhancement, :Model)
         end
 
@@ -46,10 +45,6 @@ module LinkedRails
 
         private
 
-        def enhance_routing(enhancement)
-          LinkedRails::Enhancements::RouteConcerns.add_concern(enhancement)
-        end
-
         def initialize_enhancements
           return if enhancements && method(:enhancements).owner == singleton_class
 

data/lib/linked_rails/model/filtering.rb

@@ -6,9 +6,7 @@ module LinkedRails
       extend ActiveSupport::Concern
 
       included do
-        class_attribute :default_filters, instance_accessor: false, instance_predicate: false
         class_attribute :filter_options
-        self.default_filters = {}
       end
 
       module ClassMethods
@@ -16,17 +14,17 @@ module LinkedRails
           class_variables.include?(:@@filter_options) ? super : {}
         end
 
-        def filterable(options = {})
+        def filterable(**options)
           initialize_filter_options
 
-          self.filter_options = HashWithIndifferentAccess.new(options).merge(filter_options)
+          self.filter_options = filter_options.merge(options)
 
           options.map { |k, filter| define_filter_method(k, filter) }
         end
 
         private
 
-        def boolean_filter(true_filter, false_filter, options = {})
+        def boolean_filter(true_filter, false_filter, **options)
           {
             filter: resolve_boolean_filter(true_filter, false_filter),
             values: [true, false]
@@ -36,7 +34,7 @@ module LinkedRails
         def initialize_filter_options
           return if filter_options && method(:filter_options).owner == singleton_class
 
-          self.filter_options = superclass.try(:filter_options)&.dup || {}
+          self.filter_options = superclass.try(:filter_options)&.dup || HashWithIndifferentAccess.new
         end
 
         def define_filter_method(key, filter)

data/lib/linked_rails/model/indexable.rb

@@ -15,33 +15,23 @@ module LinkedRails
           parent.send(collection_name, params) if collection_name
         end
 
-        def root_collection(params = {})
+        def root_collection(**params)
           return unless root_collection?
 
-          root_collection_class.collection_or_view(root_collection_opts, params)
-        end
-
-        def root_collection_class
-          LinkedRails.collection_class
+          default_collection_option(:collection_class).collection_or_view(
+            default_collection_options,
+            params
+          )
         end
 
         private
 
         def collection_from_parent_name(parent, _params)
-          collection_name = "#{name.underscore}_collection"
+          collection_name = "#{name.demodulize.underscore}_collection"
 
           collection_name if parent.respond_to?(collection_name, true)
         end
 
-        def grid_max_columns; end
-
-        def root_collection_opts
-          {
-            association_class: self,
-            grid_max_columns: grid_max_columns
-          }
-        end
-
         def root_collection?
           true
         end

data/lib/linked_rails/model/iri.rb

@@ -2,7 +2,7 @@
 
 module LinkedRails
   module Model
-    module Iri
+    module IRI
       extend ActiveSupport::Concern
 
       def anonymous_iri
@@ -14,13 +14,17 @@ module LinkedRails
       end
 
       # @return [RDF::URI].
-      def iri(opts = {})
+      def iri(**opts)
         return anonymous_iri if anonymous_iri?
-        return iri_with_root(root_relative_iri(opts)) if opts.present?
+        return iri_with_root(root_relative_iri(**opts)) if opts.present?
 
         @iri ||= iri_with_root(root_relative_iri)
       end
 
+      def iri_elements
+        root_relative_iri.to_s&.split('?')&.first&.split('/')&.map(&:presence)&.compact&.presence
+      end
+
       # @return [Hash]
       def iri_opts
         @iri_opts ||= {
@@ -33,14 +37,14 @@ module LinkedRails
         self.class.iri
       end
 
-      def reload(_opts = {})
+      def reload(**_opts)
         @iri = nil
         super
       end
 
       # @return [RDF::URI]
-      def root_relative_iri(opts = {})
-        RDF::URI(expand_iri_template(iri_opts.merge(opts)))
+      def root_relative_iri(**opts)
+        RDF::URI(expand_iri_template(**iri_opts.merge(opts)))
       end
 
       # @return [String, Symbol]
@@ -49,7 +53,7 @@ module LinkedRails
       private
 
       # @return [String]
-      def expand_iri_template(args = {})
+      def expand_iri_template(**args)
         iri_template.expand(args)
       end
 
@@ -58,6 +62,7 @@ module LinkedRails
         iri = root_relative_iri.dup
         iri.scheme = LinkedRails.scheme
         iri.host = LinkedRails.host
+        iri.path = iri.path.presence || '/'
         iri
       end
 
@@ -68,7 +73,7 @@ module LinkedRails
 
       # @return [URITemplate]
       def iri_template_expand_path(template_base, path)
-        tokens = template_base.tokens
+        tokens = (template_base.is_a?(String) ? LinkedRails::URITemplate.new(template_base) : template_base).tokens
 
         ind = tokens.find_index do |t|
           t.is_a?(URITemplate::RFC6570::Expression::FormQuery) || t.is_a?(URITemplate::RFC6570::Expression::Fragment)
@@ -76,18 +81,12 @@ module LinkedRails
 
         prefix = ind ? tokens[0...ind] : tokens
         suffix = ind ? tokens[ind..-1] : []
-        URITemplate.new([prefix, path, suffix].flatten.join)
+        LinkedRails::URITemplate.new([prefix, path, suffix].flatten.join)
       end
 
       # @return [URITemplate]
       def iri_template_with_fragment(template_base, fragment)
-        URITemplate.new("#{template_base.to_s.sub(/{#[\w]+}/, '').split('#').first}##{fragment}")
-      end
-
-      def singular_iri; end
-
-      def singular_iri_opts
-        {}
+        LinkedRails::URITemplate.new("#{template_base.to_s.sub(/{#[\w]+}/, '').split('#').first}##{fragment}")
       end
 
       module ClassMethods
@@ -99,7 +98,7 @@ module LinkedRails
           return if self == ApplicationRecord
 
           superclass.try(:iri_namespace) ||
-            (linked_rails_module? ? Vocab.ontola : LinkedRails.app_vocab)
+            (linked_rails_module? ? Vocab.ontola : Vocab.app)
         end
 
         def iri_value
@@ -107,14 +106,25 @@ module LinkedRails
         end
 
         def iri_template
-          @iri_template ||= URITemplate.new("/#{route_key}{/id}{#fragment}")
+          @iri_template ||= LinkedRails::URITemplate.new("/#{route_key}{/id}{#fragment}")
+        end
+
+        def iris_from_scope(scope)
+          ids = ids_for_iris(scope).uniq
+          ids.map { |id| LinkedRails.iri(path: iri_template.expand(id: id)) }
+        end
+
+        def ids_for_iris(scope)
+          scope.pluck(:id)
         end
 
         def linked_rails_module?
           (Rails.version < '6' ? parents : module_parents).include?(LinkedRails)
         end
 
-        delegate :route_key, to: :model_name
+        def route_key
+          try(:model_name)&.route_key || to_s.tableize
+        end
       end
     end
   end

data/lib/linked_rails/model/iri_mapping.rb

@@ -2,7 +2,7 @@
 
 module LinkedRails
   module Model
-    module IriMapping
+    module IRIMapping
       extend ActiveSupport::Concern
 
       module ClassMethods
@@ -10,11 +10,24 @@ module LinkedRails
           LinkedRails.iri_mapper.parent_from_params(params, user_context)
         end
 
+        def parent_from_params!(params, user_context)
+          parent_from_params(params, user_context) || raise(ActiveRecord::RecordNotFound)
+        end
+
+        def requested_action(opts, user_context)
+          action_key = opts[:params][:action_key]
+          resource = LinkedRails.iri_mapper.resource_from_iri(
+            iri_without_action(opts[:iri]),
+            user_context
+          )
+          resource&.action(action_key, user_context)
+        end
+
         def requested_index_resource(params, user_context)
           if params.key?(:parent_iri)
             collection_from_parent(index_collection_params(params, user_context))
           else
-            root_collection(index_collection_params(params, user_context))
+            root_collection(**index_collection_params(params, user_context))
           end
         end
 
@@ -25,10 +38,10 @@ module LinkedRails
         def requested_resource(opts, user_context)
           if collection_action?(opts)
             requested_index_resource(opts[:params], user_context)
+          elsif action_item_action?(opts)
+            requested_action(opts, user_context)
           elsif singular_action?(opts)
-            resource = requested_singular_resource(opts[:params], user_context)
-            resource&.singular_resource = true
-            resource
+            singular_resource(requested_singular_resource(opts[:params], user_context))
           else
             requested_single_resource(opts[:params], user_context)
           end
@@ -38,7 +51,7 @@ module LinkedRails
           if self < ActiveRecord::Base
             find_by(primary_key => params[:id]) if params.key?(:id)
           else
-            new(params)
+            new(params.except(:format))
           end
         end
 
@@ -46,10 +59,20 @@ module LinkedRails
           requested_single_resource(params, user_context) || raise(ActiveRecord::RecordNotFound)
         end
 
+        def singular_resource(resource)
+          resource&.singular_resource = true
+          resource
+        end
+
         private
 
+        def action_item_action?(opts)
+          opts[:params][:action_key].present?
+        end
+
         def collection_action?(opts)
-          %w[index create].include?(opts[:action]) && !opts[:params][:singular_route]
+          opts[:action] == 'index' ||
+            opts[:class].action_list.defined_actions[:collection].key?(opts[:action].to_sym)
         end
 
         def index_collection_params(params, user_context)
@@ -57,7 +80,13 @@ module LinkedRails
 
           {
             user_context: user_context
-          }.merge(params_hash).with_indifferent_access
+          }.merge(params_hash).symbolize_keys
+        end
+
+        def iri_without_action(url)
+          iri = RDF::URI(url)
+          iri.path = iri.path.split('/')[0...-1].join('/') if iri.path
+          iri.to_s
         end
 
         def singular_action?(opts)

data/lib/linked_rails/model/menuable.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module LinkedRails
+  module Model
+    module Menuable
+      extend ActiveSupport::Concern
+
+      def menus(user_context = nil)
+        menu_list(user_context).menus
+      end
+
+      def menu(tag, user_context = nil)
+        menu_list(user_context).menu(tag)
+      end
+
+      def menu_list(user_context = nil)
+        @menu_list ||= {}
+        @menu_list[user_context] ||= self.class.menu_class.new(resource: self, user_context: user_context)
+      end
+
+      module ClassMethods
+        def menu_class
+          @menu_class ||= "#{name}MenuList".safe_constantize || "#{superclass.name}MenuList".safe_constantize
+        end
+      end
+    end
+  end
+end