linked_rails 0.0.3 → 0.0.4

data/lib/linked_rails/params_parser.rb

@@ -1,93 +1,169 @@
 # frozen_string_literal: true
 
 module LinkedRails
-  class ParamsParser
-    attr_reader :params, :user_context
+  class ParamsParser # rubocop:disable Metrics/ClassLength
+    attr_accessor :params, :graph, :user_context
 
-    def initialize(params)
-      @user_context = params[:user_context]
-      @params = params.is_a?(Hash) ? ActionController::Parameters.new(params) : params
+    def initialize(graph: nil, params: {}, user_context: nil)
+      self.graph = graph
+      self.params = params
+      self.user_context = user_context
     end
 
-    def before_params
-      return @before_params if instance_variable_defined?(:@before_params)
-
-      values = permit_params(before: [])[:before]
-      return @before_params = nil if values.blank?
+    def attributes_from_filters(klass)
+      ActionController::Parameters.new(
+        collection_params_parser.filter_params.each_with_object({}) do |(predicate, value), hash|
+          key_and_value = filter_to_param(klass, predicate, value)
+          hash[key_and_value.first] = key_and_value.second if key_and_value
+        end
+      )
+    end
 
-      @before_params = values.map do |f|
-        key, value = f.split('=')
-        {key: RDF::URI(CGI.unescape(key)), value: value}
+    def parse_param(klass, predicate, object)
+      field_options = serializer_field(klass, predicate)
+      if field_options.is_a?(FastJsonapi::Attribute)
+        parse_attribute(klass, field_options, object.value)
+      elsif field_options.is_a?(FastJsonapi::Relationship)
+        parse_association(klass, field_options, object)
       end
     end
 
-    def collection_params
-      return @collection_params if instance_variable_defined?(:@collection_params)
+    # Recursively parses a resource from graph
+    def parse_resource(subject, klass)
+      graph
+        .query([subject])
+        .map { |statement| parse_statement(statement, klass) }
+        .compact
+        .reduce({}) { |h, (k, v)| add_param(h, k, v) }
+    end
 
-      values = permit_params(:display, :page_size, :title, :type)
+    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
 
-      filter = filter_params
-      values[:filter] = filter if filter
+    def associated_class_from_params(reflection, object)
+      return reflection.klass unless reflection.polymorphic?
 
-      sort = sorting_params
-      values[:sort] = sort if sort
+      query = graph.query(subject: object, predicate: Vocab.rdfv[:type])
 
-      values[:user_context] = user_context if user_context
+      raise("No type given for '#{object}' referenced by polymorphic association '#{reflection.name}'") if query.empty?
 
-      @collection_params = values
+      iri_to_class(query.first.object)
     end
 
-    def collection_view_params
-      return @collection_view_params if instance_variable_defined?(:@collection_view_params)
+    def collection_params_parser
+      @collection_params_parser ||= LinkedRails::CollectionParamsParser.new(params.merge(user_context: user_context))
+    end
+
+    def filter_to_param(klass, predicate, value)
+      options = serializer_field(klass, predicate)
+      return unless value.count == 1 && options.present?
+
+      parsed_value = value.first.start_with?('http') ? RDF::URI(value.first) : RDF::Literal(value.first)
+      parse_param(
+        klass,
+        options.predicate,
+        parsed_value
+      )
+    end
 
-      values = permit_params(:page)
+    def foreign_key_for_reflection(reflection)
+      if reflection.options[:through]
+        reflection.has_one? ? "#{reflection.name}_id" : "#{reflection.name.to_s.singularize}_ids"
+      elsif reflection.belongs_to?
+        reflection.foreign_key
+      end
+    end
 
-      before = before_params
-      values[:before] = before if before
+    def iri_to_class(iri)
+      iri.to_s.split(Vocab.app.to_s).pop&.classify&.safe_constantize ||
+        LinkedRails.linked_models.detect { |klass| klass.iri == iri }
+    end
 
-      @collection_view_params = values
+    def nested_attributes(object, klass, association, collection)
+      nested_resources =
+        if graph.query([object, Vocab.rdfv[:first], nil]).present?
+          nested_attributes_from_list(object, klass)
+        else
+          parsed = parse_nested_resource(object, klass)
+          collection ? {rand(1_000_000_000).to_s => parsed} : parsed
+        end
+      ["#{association}_attributes", nested_resources]
     end
 
-    def filter_params # rubocop:disable Metrics/AbcSize
-      return @filter_params if instance_variable_defined?(:@filter_params)
+    def nested_attributes_from_list(object, klass)
+      Hash[
+        RDF::List.new(subject: object, graph: graph)
+          .map { |nested| [rand(1_000_000_000).to_s, parse_nested_resource(nested, klass)] }
+      ]
+    end
 
-      values = permit_params(filter: [])[:filter] || permit_params(filter: {})[:filter]
-      return @filter_params = values if values.is_a?(Hash)
-      return @filter_params = {} if values.blank?
+    def parse_association(klass, field_options, object)
+      association = field_options.association || field_options.key
+      reflection = klass.reflect_on_association(association) || raise("#{association} not found for #{name}")
 
-      @filter_params = values.each_with_object({}) do |f, hash|
-        values = f.split('=')
-        key = RDF::URI(CGI.unescape(values.first))
-        hash[key] ||= []
-        hash[key] << CGI.unescape(values.second)
+      if graph&.has_subject?(object)
+        association_klass = associated_class_from_params(reflection, object)
+        nested_attributes(object, association_klass, association, reflection.collection?)
+      elsif object.iri?
+        parse_iri_param(object, reflection)
       end
     end
 
-    def sorting_params
-      return @sorting_params if instance_variable_defined?(:@sorting_params)
+    def parse_attribute(klass, field_options, value)
+      parsed_value = parse_blob_attribute(value) || parse_enum_attribute(klass, field_options.key, value) || value
 
-      values = permit_params(sort: [])[:sort]
-      return @sorting_params = nil if values.blank?
+      [field_options.key, parsed_value]
+    end
 
-      @sorting_params = values.map do |f|
-        parse_filter_value(f)
-      end
+    def parse_blob_attribute(value)
+      params["<#{value}>"] if value.starts_with?(Vocab.ll['blobs/'])
     end
 
-    private
+    def parse_enum_attribute(klass, key, value)
+      opts = RDF::Serializers.serializer_for(klass)&.enum_options(key)
+      return if opts.blank?
+
+      opts.detect { |_k, options| options.iri == value }&.first&.to_s
+    end
 
-    def parse_filter_value(value)
-      return value if value.is_a?(Hash)
+    def parse_iri_param(iri, reflection)
+      resource = LinkedRails.iri_mapper.resource_from_iri(iri, user_context)
+      return unless resource
+
+      key = foreign_key_for_reflection(reflection)
+
+      value = resource&.try(reflection.association_primary_key) if key
+
+      [key, value] if value
+    end
+
+    def parse_nested_resource(object, klass)
+      resource = parse_resource(object, klass)
+      resource[:id] ||= LinkedRails.iri_mapper.opts_from_iri(object)[:params][:id] if object.iri?
+      resource
+    end
 
-      key, value = value.split('=')
-      {key: RDF::URI(CGI.unescape(key)), direction: value}
+    def parse_statement(statement, klass)
+      parse_param(klass, statement.predicate, statement.object)
     end
 
-    def permit_params(*keys)
-      params
-        .permit(*keys)
-        .to_h
-        .with_indifferent_access
+    def serializer_field(klass, predicate)
+      field = klass.try(:predicate_mapping).try(:[], predicate)
+      Rails.logger.info("#{predicate} not found for #{klass || 'nil'}") if field.blank?
+      field
     end
   end
 end

data/lib/linked_rails/policy/attribute_conditions.rb

@@ -22,7 +22,7 @@ module LinkedRails
       module ClassMethods
         private
 
-        def has_properties_shapes(properties) # rubocop:disable Naming/PredicateName
+        def has_properties_shapes(properties)
           properties.map do |key, boolean|
             SHACL::PropertyShape.new(
               path: policy_class.predicate_for_key(key),
@@ -32,7 +32,7 @@ module LinkedRails
           end
         end
 
-        def has_values_shapes(values) # rubocop:disable Naming/PredicateName
+        def has_values_shapes(values)
           values.map do |key, value|
             enum = RDF::Serializers.serializer_for(policy_class).enum_options(key).try(:[], value)
             santized_value = enum ? -> { enum.iri } : value

data/lib/linked_rails/policy.rb

@@ -15,7 +15,7 @@ module LinkedRails
       enhanceable :policy_class, :Policy
       class_attribute :_permitted_attributes
 
-      attr_reader :message, :user_context, :record
+      attr_reader :action_status, :message, :user_context, :record
 
       def initialize(user_context, record)
         @user_context = user_context
@@ -23,11 +23,11 @@ module LinkedRails
       end
     end
 
-    def create_child?(klass, opts = {})
+    def create_child?(klass, **opts)
       child_policy(klass, opts).create?
     end
 
-    def index_children?(klass, opts = {})
+    def index_children?(klass, **opts)
       child_policy(klass, opts).show?
     end
 
@@ -38,6 +38,10 @@ module LinkedRails
         .flatten
     end
 
+    def policy_class
+      self.class.policy_class
+    end
+
     def show?
       false
     end
@@ -64,25 +68,28 @@ module LinkedRails
       end
     end
 
-    def child_policy(klass, opts = {})
+    def child_policy(klass, **opts)
       Pundit.policy(user_context, record.build_child(klass, opts.merge(user_context: user_context)))
     end
 
-    def forbid_with_message(message)
+    def forbid_with_message(message, status = nil)
+      forbid_with_status(status) if status
       @message = message
       false
     end
 
+    def forbid_with_status(status, message = nil)
+      forbid_with_message(message) if message
+      @action_status = status
+      false
+    end
+
     def parent_policy
       return if record.try(:parent).blank?
 
       @parent_policy ||= Pundit.policy(user_context, record.parent)
     end
 
-    def policy_class
-      self.class.policy_class
-    end
-
     def sanitize_array_attribute(attr)
       [attr, attr => []]
     end
@@ -118,7 +125,7 @@ module LinkedRails
     end
 
     module ClassMethods
-      def condition_for(attr, pass, shape_opts = {})
+      def condition_for(attr, pass, **shape_opts)
         raise("#{attr} not permitted by #{self}") if attribute_options(attr).blank? && pass.permission_required?
 
         alternatives = node_shapes_for(attr, **shape_opts)
@@ -131,6 +138,10 @@ module LinkedRails
         end
       end
 
+      def policy_class
+        @policy_class ||= name.sub(/Policy/, '').classify.safe_constantize
+      end
+
       def permitted_attributes
         initialize_permitted_attributes
 
@@ -165,22 +176,18 @@ module LinkedRails
         self._permitted_attributes = superclass.try(:_permitted_attributes)&.dup || []
       end
 
-      def permit_attributes(attrs, conditions = {})
+      def permit_attributes(attrs, **conditions)
         permitted_attributes << {attributes: attrs, conditions: conditions, options: {}}
       end
 
-      def permit_array_attributes(attrs, conditions = {})
+      def permit_array_attributes(attrs, **conditions)
         permitted_attributes << {attributes: attrs, conditions: conditions, options: {array: true}}
       end
 
-      def permit_nested_attributes(attrs, conditions = {})
+      def permit_nested_attributes(attrs, **conditions)
         permitted_attributes << {attributes: attrs, conditions: conditions, options: {nested: true}}
       end
 
-      def policy_class
-        @policy_class ||= name.sub(/Policy/, '').classify.safe_constantize
-      end
-
       def property_shapes(conditions)
         conditions.map { |key, options| send("#{key}_shapes", options) }.flatten.compact
       end

data/lib/linked_rails/rdf_error.rb

@@ -4,12 +4,12 @@ module LinkedRails
   class RDFError
     include ActiveModel::Model
 
-    attr_accessor :error, :iri, :status
-    delegate :message, to: :error
+    attr_accessor :error, :iri, :message, :status
 
     def initialize(status, requested_url, original_error)
       self.status = status
       self.error = original_error.is_a?(StandardError) ? original_error : original_error.new
+      self.message = error.message unless Rails.env.production?
       self.iri = ::RDF::URI(requested_url)
     end
 

data/lib/linked_rails/routes.rb

@@ -4,7 +4,7 @@ require 'linked_rails/constraints/whitelist'
 
 module LinkedRails
   module Routes
-    def use_linked_rails(opts = {}) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+    def use_linked_rails(**opts) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
       constraints(LinkedRails::Constraints::Whitelist) do
         post 'spi/bulk', to: "#{opts.fetch(:bulk, 'linked_rails/bulk')}#show"
       end
@@ -22,24 +22,28 @@ module LinkedRails
 
       get '(*parent_iri)/actions', to: "#{opts.fetch(:actions, 'linked_rails/actions')}/items#index"
       get '(*parent_iri)/actions/:id', to: "#{opts.fetch(:actions, 'linked_rails/actions')}/items#show"
-      get '(*parent_iri)/new', to: "#{opts.fetch(:actions, 'linked_rails/actions')}/items#show", id: :create
-      get '(*parent_iri)/edit', to: "#{opts.fetch(:actions, 'linked_rails/actions')}/items#show", id: :update
-      get '(*parent_iri)/delete', to: "#{opts.fetch(:actions, 'linked_rails/actions')}/items#show", id: :destroy
-      get '(*parent_iri)/trash', to: "#{opts.fetch(:actions, 'linked_rails/actions')}/items#show", id: :trash
-      get '(*parent_iri)/untrash', to: "#{opts.fetch(:actions, 'linked_rails/actions')}/items#show", id: :untrash
     end
 
-    def linked_resource(klass, controller: nil, nested: false, &block)
+    def linked_resource(klass, controller: nil, collection: true, nested: false, resource: true, &block) # rubocop:disable Metrics/MethodLength, Metrics/ParameterLists
       options = route_options(klass, controller, nested, klass.route_key)
 
+      if collection
+        get(options[:parentable_path], to: "#{options[:controller]}#index")
+        route_block(
+          klass,
+          :collection,
+          controller: options[:controller],
+          prefix: options[:parentable_path]
+        ).call
+      end
+
+      return unless resource
+
       resources(
         options[:route_name],
         active_controller_opts(options),
-        &route_block(klass, &block)
+        &route_block(klass, :resource, &block)
       )
-
-      post(options[:parentable_path], to: "#{options[:controller]}#create") if options[:creatable]
-      get(options[:parentable_path], to: "#{options[:controller]}#index")
     end
 
     def singular_linked_resource(klass, controller: nil, nested: true, &block)
@@ -48,10 +52,8 @@ module LinkedRails
       resource(
         options[:route_name],
         active_controller_opts(options).merge(singular_route: true),
-        &route_block(klass, &block)
+        &route_block(klass, :singular, &block)
       )
-
-      post(options[:parentable_path], to: "#{options[:controller]}#create", singular_route: true) if options[:creatable]
     end
 
     def find_tenant_route
@@ -60,6 +62,16 @@ module LinkedRails
 
     private
 
+    def action_routes(controller, prefix, key, value)
+      path = value.fetch(:action_path, key)
+      action = value.fetch(:action_name)
+      get([prefix, path].compact.join('/'), action: action, action_key: key, controller: controller)
+      return if value[:target_path].nil?
+
+      method = value.fetch(:http_method).downcase
+      send(method, [prefix, value.fetch(:target_path)].compact.join('/'), action: key, controller: controller)
+    end
+
     def active_controller_opts(route_options)
       {
         controller: route_options[:controller],
@@ -68,22 +80,20 @@ module LinkedRails
       }
     end
 
-    def creatable(klass)
-      klass.enhanced_with?(LinkedRails::Enhancements::Creatable, :Routing)
-    end
-
-    def route_block(klass)
+    def route_block(klass, action_type, controller: nil, prefix: nil)
       lambda do
-        include_route_concerns(klass: klass)
-
+        klass.action_list.defined_actions[action_type].each do |key, value|
+          action_routes(controller, prefix, key, value)
+        end
         yield if block_given?
       end
     end
 
     def route_options(klass, controller, nested, path)
+      touch_controller(klass)
+
       {
         controller: controller || klass.name.tableize,
-        creatable: creatable(klass),
         nested: nested,
         only: %i[show],
         parentable_path: "(*parent_iri)/#{path}",
@@ -91,6 +101,11 @@ module LinkedRails
         route_name: klass.name.demodulize.tableize
       }.with_indifferent_access
     end
+
+    # Make sure all actions are initialized before generating the routes
+    def touch_controller(klass)
+      klass.controller_class
+    end
   end
 end
 

data/lib/linked_rails/serializer/actionable.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module LinkedRails
+  module Serializer
+    module Actionable
+      extend ActiveSupport::Concern
+
+      included do
+        has_many :favorite_actions,
+                 predicate: Vocab.ontola[:favoriteAction] do |object|
+          object.try(:favorite_actions)
+        end
+        statements :action_triples
+      end
+
+      module ClassMethods
+        def action_triples(object, _params)
+          if object.iri.anonymous? && !object.try(:singular_resource?)
+            []
+          else
+            object.try(:action_triples) || []
+          end
+        end
+      end
+    end
+  end
+end

data/lib/linked_rails/serializer/menuable.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module LinkedRails
+  module Serializer
+    module Menuable
+      extend ActiveSupport::Concern
+
+      included do
+        include_menus
+      end
+
+      module ClassMethods
+        def inherited(target)
+          super
+          target.include_menus
+        end
+
+        def include_menus
+          serializable_class.try(:menu_class)&.defined_menus&.keys&.each do |menu|
+            has_one "#{menu}_menu",
+                    predicate: Vocab.ontola["#{menu.to_s.camelize(:lower)}Menu"],
+                    if: method(:named_object?),
+                    polymorphic: true do |object, opts|
+              object.menu(menu, opts[:scope])
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/linked_rails/serializer/singularable.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module LinkedRails
+  module Serializer
+    module Singularable
+      extend ActiveSupport::Concern
+
+      included do
+        statements :same_as_statement
+
+        def self.same_as_statement(object, _params)
+          return [] unless object.try(:singular_resource?) && object.singular_iri != object.iri
+
+          [
+            RDF::Statement.new(
+              object.singular_iri,
+              Vocab.owl.sameAs,
+              object.iri,
+              graph_name: Vocab.ll[:supplant]
+            )
+          ]
+        end
+      end
+    end
+  end
+end

data/lib/linked_rails/serializer.rb

@@ -1,11 +1,19 @@
 # frozen_string_literal: true
 
+require_relative 'serializer/actionable'
+require_relative 'serializer/menuable'
+require_relative 'serializer/singularable'
+
 module LinkedRails
   module Serializer
     extend ActiveSupport::Concern
 
     included do
       include RDF::Serializers::ObjectSerializer
+      include Serializer::Actionable
+      include Serializer::Menuable
+      include Serializer::Singularable
+
       extend Enhanceable
 
       enhanceable :serializable_class, :Serializer
@@ -15,7 +23,7 @@ module LinkedRails
       set_id :iri
 
       attribute :rdf_type, predicate: Vocab.rdfv.type, datatype: Vocab.xsd.anyURI
-      attribute :created_at, predicate: Vocab.schema[:dateCreated] do |object|
+      attribute :created_at, predicate: Vocab.schema.dateCreated do |object|
         object.try(:created_at)
       end
     end
@@ -58,8 +66,7 @@ module LinkedRails
         ]
       end
 
-      # rubocop:disable Naming/PredicateName
-      def has_one(key, opts = {})
+      def has_one(key, **opts)
         opts[:id_method_name] = :iri
 
         return super if block_given?
@@ -69,7 +76,7 @@ module LinkedRails
         end
       end
 
-      def has_many(key, opts = {})
+      def has_many(key, **opts)
         opts[:id_method_name] = :iri
 
         return super if block_given?
@@ -78,7 +85,6 @@ module LinkedRails
           object.send(key)
         end
       end
-      # rubocop:enable Naming/PredicateName
 
       def named_object?(object)
         !object.iri.anonymous?
@@ -88,6 +94,11 @@ module LinkedRails
         false
       end
 
+      def secret_attribute(key, **opts)
+        opts[:if] = method(:never)
+        attribute(key, **opts)
+      end
+
       def serializable_class
         @serializable_class ||= name.gsub('Serializer', '').safe_constantize
       end
@@ -100,16 +111,18 @@ module LinkedRails
         end
       end
 
-      def with_collection(name, opts = {})
+      def with_collection(name, **opts) # rubocop:disable Metrics/AbcSize
         collection_name = "#{name.to_s.singularize}_collection"
-        page_size = opts.delete(:page_size)
-        display = opts.delete(:display)
         opts[:association] ||= name
         opts[:polymorphic] ||= true
         opts[:if] ||= method(:named_object?)
 
-        has_one collection_name, opts do |object, params|
-          object.send(collection_name, user_context: params[:scope], display: display, page_size: page_size)
+        collection_opts = {}
+        collection_opts[:page_size] = opts.delete(:page_size) if opts.key?(:page_size)
+        collection_opts[:display] = opts.delete(:display) if opts.key?(:display)
+
+        has_one collection_name, **opts do |object, params|
+          object.send(collection_name, **collection_opts.merge(user_context: params[:scope]))
         end
       end