linked_rails 0.0.1 → 0.0.4.pre.g2c53724b3

data/lib/linked_rails/middleware/linked_data_params.rb

@@ -1,8 +1,13 @@
 # frozen_string_literal: true
 
+# require 'empathy/emp_json'
+
 module LinkedRails
   module Middleware
-    class LinkedDataParams # rubocop:disable Metrics/ClassLength
+    class LinkedDataParams
+      include ::Empathy::EmpJson::Helpers::Slices
+      include ::Empathy::EmpJson::Helpers::Parsing
+
       def initialize(app)
         @app = app
       end
@@ -10,40 +15,15 @@ module LinkedRails
       def call(env)
         req = Rack::Request.new(env)
         params_from_query(req)
-        params_from_graph(req)
+        params_from_slice(req)
 
         @app.call(env)
       end
 
       private
 
-      def add_param(hash, key, value) # rubocop:disable Metrics/MethodLength
-        case hash[key]
-        when nil
-          hash[key] = value
-        when Hash
-          hash[key].merge!(value)
-        when Array
-          hash[key].append(value)
-        else
-          hash[key] = [hash[key], value]
-        end
-        hash
-      end
-
-      def associated_class_from_params(reflection, graph, subject)
-        return reflection.klass unless reflection.polymorphic?
-
-        query = graph.query(subject: subject, predicate: Vocab.rdfv[:type])
-        if query.empty?
-          raise("No type given for '#{subject}' referenced by polymorphic association '#{reflection.name}'")
-        end
-
-        iri_to_class(query.first.object)
-      end
-
-      def blob_attribute(base_params, value)
-        base_params["<#{value}>"] if value.starts_with?(Vocab.ll['blobs/'])
+      def add_param_from_query(data, target_class, key, value)
+        data[target_class.predicate_mapping[RDF::URI(key)].key] = value
       end
 
       def convert_query_params(request, target_class)
@@ -56,76 +36,32 @@ module LinkedRails
         request.update_param(class_key, data) if data.present?
       end
 
-      def add_param_from_query(data, target_class, key, value)
-        data[target_class.predicate_mapping[RDF::URI(key)].key] = value
-      end
-
-      def enum_attribute(klass, key, value)
-        opts = RDF::Serializers.serializer_for(klass).try(:enum_options, key)
-        return if opts.blank?
-
-        opts.detect { |_k, options| options.iri == value }&.first&.to_s
-      end
-
-      def graph_from_request(request)
-        request_graph = request.delete_param("<#{Vocab.ll[:graph].value}>")
-        return if request_graph.blank?
+      def slice_from_request(request)
+        return unless request.content_type == Mime::Type.lookup_by_extension(:empjson).to_s
 
-        RDF::Graph.load(
-          request_graph[:tempfile].path,
-          content_type: request_graph[:type],
-          canonicalize: true,
-          intern: false
-        )
-      end
-
-      def iri_to_class(iri)
-        iri.to_s.split(LinkedRails.app_vocab.to_s).pop&.classify&.safe_constantize ||
-          ApplicationRecord.descendants.detect { |klass| klass.iri == iri }
-      end
-
-      def logger
-        Rails.logger
-      end
+        body = request.body.read
 
-      def nested_attributes(base_params, graph, subject, klass, association, collection) # rubocop:disable Metrics/ParameterLists
-        nested_resources =
-          if graph.query([subject, Vocab.rdfv[:first], nil]).present?
-            nested_attributes_from_list(base_params, graph, subject, klass)
-          else
-            parsed = parse_nested_resource(base_params, graph, subject, klass)
-            collection ? {rand(1_000_000_000).to_s => parsed} : parsed
-          end
-        ["#{association}_attributes", nested_resources]
+        JSON.parse(body) if body.present?
       end
 
-      def nested_attributes_from_list(base_params, graph, subject, klass)
-        Hash[
-          RDF::List.new(subject: subject, graph: graph)
-            .map { |nested| [rand(1_000_000_000).to_s, parse_nested_resource(base_params, graph, nested, klass)] }
-        ]
-      end
-
-      # Converts a serialized graph from a multipart request body to a nested
-      # attributes hash.
+      # Converts a emp slice from to a nested attributes hash.
       #
-      # The graph sent to the server should be sent under the `ll:graph` form name.
-      # The entrypoint for the graph is the `ll:targetResource` subject, which is
+      # The entrypoint for the slice is the `.` subject, which is
       # assumed to be the resource intended to be targeted by the request (i.e. the
       # resource to be created, updated, or deleted).
       #
       # @return [Hash] A hash of attributes, empty if no statements were given.
-      def params_from_graph(request)
-        graph = graph_from_request(request)
+      def params_from_slice(request)
+        slice = slice_from_request(request)
 
-        return unless graph
+        return unless slice
 
-        request.update_param(:body_graph, graph)
+        request.env['emp_json'] = slice
         target_class = target_class_from_path(request)
         return if target_class.blank?
 
-        update_actor_param(request, graph)
-        update_target_params(request, graph, target_class)
+        update_actor_param(request, slice)
+        update_target_params(request, slice, target_class)
       end
 
       def params_from_query(request)
@@ -135,87 +71,30 @@ module LinkedRails
         convert_query_params(request, target_class)
       end
 
-      def parse_nested_resource(base_params, graph, subject, klass)
-        resource = parse_resource(base_params, graph, subject, klass)
-        resource[:id] ||= LinkedRails.iri_mapper.opts_from_iri(subject)[:params][:id] if subject.iri?
-        resource
-      end
-
-      # Recursively parses a resource from graph
-      def parse_resource(base_params, graph, subject, klass)
-        graph
-          .query([subject])
-          .map { |statement| parse_statement(base_params, graph, statement, klass) }
-          .compact
-          .reduce({}) { |h, (k, v)| add_param(h, k, v) }
-      end
-
-      def parse_statement(base_params, graph, statement, klass)
-        field = serializer_field(klass, statement.predicate)
-        if field.is_a?(FastJsonapi::Attribute)
-          parsed_attribute(base_params, klass, field.key, statement.object.value)
-        elsif field.is_a?(FastJsonapi::Relationship)
-          parsed_association(base_params, graph, statement.object, klass, field.association || field.key)
-        end
-      end
-
-      def parsed_association(base_params, graph, object, klass, association)
-        reflection = klass.reflect_on_association(association) || raise("#{association} not found for #{klass}")
-
-        if graph.has_subject?(object)
-          association_klass = associated_class_from_params(reflection, graph, object)
-          nested_attributes(base_params, graph, object, association_klass, association, reflection.collection?)
-        elsif object.iri?
-          attributes_from_iri(object, association, reflection)
-        end
-      end
-
-      def attributes_from_iri(object, association, reflection)
-        if reflection.options[:through]
-          key = reflection.has_one? ? "#{association}_id" : "#{association.to_s.singularize}_ids"
-        elsif reflection.belongs_to?
-          key = reflection.foreign_key
-        end
-        return unless key
-
-        resource = LinkedRails.iri_mapper.resource_from_iri(object, nil)
-        value = resource&.send(reflection.association_primary_key)
-
-        [key, value] if value
-      end
-
-      def parsed_attribute(base_params, klass, key, value)
-        [key, blob_attribute(base_params, value) || enum_attribute(klass, key, value) || value]
-      end
-
-      def serializer_field(klass, predicate)
-        field = klass.try(:predicate_mapping).try(:[], predicate)
-        logger.info("#{predicate} not found for #{klass || 'nil'}") if field.blank?
-        field
-      end
-
       def target_class_from_path(request) # rubocop:disable Metrics/AbcSize
         opts = LinkedRails.iri_mapper.opts_from_iri(
           request.base_url + request.env['REQUEST_URI'],
           method: request.request_method
         )
 
-        logger.info("No class found for #{request.base_url + request.env['REQUEST_URI']}") unless opts[:class]
+        Rails.logger.info("No class found for #{request.base_url + request.env['REQUEST_URI']}") unless opts[:class]
 
         opts[:class]
       end
 
-      def update_actor_param(request, graph)
-        actor = graph.query([Vocab.ll[:targetResource], Vocab.schema.creator]).first
+      def update_actor_param(request, slice)
+        actor = values_from_slice(slice, '.', Vocab.schema.creator)
+
         return if actor.blank?
 
-        request.update_param(:actor_iri, actor.object)
-        graph.delete(actor)
+        request.update_param(:actor_iri, emp_to_primitive(actor))
       end
 
-      def update_target_params(request, graph, target_class)
+      def update_target_params(request, slice, target_class)
         key = target_class.to_s.demodulize.underscore
-        from_body = parse_resource(request.params, graph, Vocab.ll[:targetResource], target_class)
+
+        parser = ParamsParser.new(slice: slice, params: request.params)
+        from_body = parser.parse_resource('.', target_class)
 
         request.update_param(key, from_body.merge(request.params[key] || {}))
       end

data/lib/linked_rails/model/actionable.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module LinkedRails
+  module Model
+    module Actionable
+      extend ActiveSupport::Concern
+
+      def actions(user_context = nil)
+        action_list(user_context).actions
+      end
+
+      def action(tag, user_context = nil)
+        actions(user_context).find { |a| a.tag == tag }
+      end
+
+      def action_list(user_context)
+        @action_list ||= {}
+        @action_list[user_context] ||= self.class.action_list.new(resource: self, user_context: user_context)
+      end
+
+      def action_triples
+        @action_triples ||= triples_for_actions(actions) + triples_for_actions(collection_actions)
+      end
+
+      def collection_actions
+        (try(:collections) || []).map do |opts|
+          collection_for(opts[:name]).actions
+        end.flatten
+      end
+
+      def favorite_actions
+        actions.filter(&:favorite)
+      end
+
+      private
+
+      def triples_for_actions(actions)
+        actions.flat_map do |action|
+          [
+            [iri, action.predicate, action.iri],
+            [iri, Vocab.schema.potentialAction, action.iri]
+          ]
+        end
+      end
+
+      module ClassMethods
+        def action_list
+          @action_list ||= define_action_list
+        end
+
+        private
+
+        def action_superclass
+          superclass.try(:action_list) || LinkedRails.action_list_parent_class
+        end
+
+        def define_action_list
+          klass = Class.new(action_superclass)
+          actionable_class = self
+          klass.define_singleton_method(:actionable_class) do
+            actionable_class
+          end
+          klass
+        end
+      end
+    end
+  end
+end

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