linked_rails 0.0.3 → 0.0.4.pre.g2c53724b3

data/lib/linked_rails/params_parser.rb

@@ -1,93 +1,170 @@
 # frozen_string_literal: true
 
 module LinkedRails
-  class ParamsParser
-    attr_reader :params, :user_context
+  class ParamsParser # rubocop:disable Metrics/ClassLength
+    include ::Empathy::EmpJson::Helpers::Slices
+    include ::Empathy::EmpJson::Helpers::Parsing
 
-    def initialize(params)
-      @user_context = params[:user_context]
-      @params = params.is_a?(Hash) ? ActionController::Parameters.new(params) : params
+    attr_accessor :params, :slice, :user_context
+    delegate :filter_params, to: :collection_params_parser
+
+    def initialize(slice: nil, params: {}, user_context: nil)
+      self.slice = slice
+      self.params = params
+      self.user_context = user_context
     end
 
-    def before_params
-      return @before_params if instance_variable_defined?(:@before_params)
+    def attributes_from_filters(klass)
+      ActionController::Parameters.new(
+        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
 
-      values = permit_params(before: [])[:before]
-      return @before_params = nil if values.blank?
+    def parse_param(klass, predicate, object)
+      field_options = serializer_field(klass, predicate) unless predicate == '_id'
+      if field_options.is_a?(FastJsonapi::Attribute)
+        parse_attribute(klass, field_options, emp_to_primitive(object))
+      elsif field_options.is_a?(FastJsonapi::Relationship)
+        parse_association(klass, field_options, emp_to_primitive(object))
+      end
+    end
 
-      @before_params = values.map do |f|
-        key, value = f.split('=')
-        {key: RDF::URI(CGI.unescape(key)), value: value}
+    # Recursively parses a resource from slice
+    def parse_resource(subject, klass)
+      (record_from_slice(slice, subject) || {}).reduce({}) do |h, (k, v)|
+        (v.is_a?(Array) ? v : [v]).each do |value|
+          param = parse_param(klass, RDF::URI(k), value)
+          param ? add_param(h, param.first, param.second) : h
+        end
+        h
       end
     end
 
-    def collection_params
-      return @collection_params if instance_variable_defined?(:@collection_params)
+    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
 
-      values = permit_params(:display, :page_size, :title, :type)
+    def associated_class_from_params(reflection, object)
+      return reflection.klass unless reflection.polymorphic?
 
-      filter = filter_params
-      values[:filter] = filter if filter
+      type = values_from_slice(slice, object, Vocab.rdfv[:type])
 
-      sort = sorting_params
-      values[:sort] = sort if sort
+      raise("No type given for '#{object}' referenced by polymorphic association '#{reflection.name}'") if type.blank?
 
-      values[:user_context] = user_context if user_context
+      iri_to_class(type)
+    end
 
-      @collection_params = values
+    def collection_params_parser
+      @collection_params_parser ||= LinkedRails::CollectionParamsParser.new(params.merge(user_context: user_context))
     end
 
-    def collection_view_params
-      return @collection_view_params if instance_variable_defined?(:@collection_view_params)
+    def filter_to_param(klass, predicate, value)
+      options = serializer_field(klass, predicate)
+      return unless value.count == 1 && options.present?
 
-      values = permit_params(:page)
+      parsed_value = value.first.start_with?('http') ? RDF::URI(value.first) : value.first
+      parse_param(
+        klass,
+        options.predicate,
+        object_to_value(parsed_value)
+      )
+    end
 
-      before = before_params
-      values[:before] = before if before
+    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
 
-      @collection_view_params = values
+    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
 
-    def filter_params # rubocop:disable Metrics/AbcSize
-      return @filter_params if instance_variable_defined?(:@filter_params)
+    def nested_attributes(object, klass, association, collection)
+      parsed = parse_nested_resource(object, klass)
+      nested_resources = collection ? {rand(1_000_000_000).to_s => parsed} : parsed
+
+      ["#{association}_attributes", nested_resources]
+    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 slice&.key?(object.to_s)
+        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_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.to_s]
+    end
 
-      @sorting_params = values.map do |f|
-        parse_filter_value(f)
-      end
+    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
 
-    private
+    def parse_iri_param(iri, reflection)
+      key = foreign_key_for_reflection(reflection)
+      value = parse_iri_param_value(iri, reflection) if key
+
+      [key, value.to_s] if value
+    end
 
-    def parse_filter_value(value)
-      return value if value.is_a?(Hash)
+    def parse_iri_param_value(iri, reflection)
+      resource = LinkedRails.iri_mapper.resource_from_iri(iri, user_context)
 
-      key, value = value.split('=')
-      {key: RDF::URI(CGI.unescape(key)), direction: value}
+      resource&.try(reflection.association_primary_key)
+    end
+
+    def parse_nested_resource(object, klass)
+      resource = parse_resource(object, klass)
+      resource[:id] ||= nested_resource_id(object)
+      resource
+    end
+
+    def nested_resource_id(object)
+      return unless object.iri?
+
+      opts = LinkedRails.iri_mapper.opts_from_iri(object)
+      if opts[:class].method(:requested_single_resource).owner == LinkedRails::Model::IRIMapping::ClassMethods
+        opts[:params][:id]
+      else
+        opts[:class].requested_single_resource(opts[:params], nil)&.id
+      end
     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,12 +23,12 @@ module LinkedRails
       end
     end
 
-    def create_child?(klass, opts = {})
-      child_policy(klass, opts).create?
+    def create_child?(klass, **opts)
+      child_policy(klass, **opts).create?
     end
 
-    def index_children?(klass, opts = {})
-      child_policy(klass, opts).show?
+    def index_children?(klass, **opts)
+      child_policy(klass, **opts).show?
     end
 
     def permitted_attributes
@@ -38,6 +38,14 @@ module LinkedRails
         .flatten
     end
 
+    def permitted_attributes_from_filters(filters)
+      params_parser(filters).attributes_from_filters(policy_class).permit(permitted_attributes)
+    end
+
+    def policy_class
+      self.class.policy_class
+    end
+
     def show?
       false
     end
@@ -64,25 +72,32 @@ module LinkedRails
       end
     end
 
-    def child_policy(klass, opts = {})
-      Pundit.policy(user_context, record.build_child(klass, opts.merge(user_context: user_context)))
+    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 params_parser(filters)
+      LinkedRails::ParamsParser.new(user_context: user_context, params: {filter: filters})
+    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,17 +133,16 @@ module LinkedRails
     end
 
     module ClassMethods
-      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)
-        if alternatives.count == 1
-          Condition.new(shape: alternatives.first, pass: pass)
-        elsif alternatives.count.positive?
-          Condition.new(shape: SHACL::NodeShape.new(or: alternatives), pass: pass)
-        else
-          pass
-        end
+      def condition_alternatives(attr, permission_required)
+        raise("#{attr} not permitted by #{self}") if attribute_options(attr).blank? && permission_required
+
+        attribute_options(attr)
+          .select { |opts| opts[:conditions].present? }
+          .map { |opts| property_shapes(opts[:conditions]) }
+      end
+
+      def policy_class
+        @policy_class ||= name.sub(/Policy/, '').classify.safe_constantize
       end
 
       def permitted_attributes
@@ -143,44 +157,24 @@ module LinkedRails
         permitted_attributes.select { |opts| opts[:attributes].include?(attr) }
       end
 
-      def condition_alternatives(attr)
-        attribute_options(attr)
-          .select { |opts| opts[:conditions].present? }
-          .map { |opts| opts[:conditions] }
-      end
-
-      def node_shapes_for(attr, property: [], sh_not: [])
-        alternatives = condition_alternatives(attr)
-        alternatives = [[]] if alternatives.empty? && (property.any? || sh_not.any?)
-
-        alternatives.map do |props|
-          properties = property_shapes(props) + property
-          SHACL::NodeShape.new(property: properties, sh_not: sh_not)
-        end
-      end
-
       def initialize_permitted_attributes
         return if _permitted_attributes && method(:_permitted_attributes).owner == singleton_class
 
         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/railtie.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module LinkedRails
+  class Railtie < Rails::Railtie
+    initializer :add_welcome_page do
+      ActiveSupport.on_load(:action_controller_base) do
+        require_relative '../rails/welcome_controller'
+      end
+    end
+  end
+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/renderers.rb

@@ -19,6 +19,7 @@ module LinkedRails
         end
 
         register_renderer(%i[hndjson], ['application/hex+x-ndjson'], :hndjson)
+        register_renderer(%i[empjson], ['application/empathy+json'], :empjson)
         rdf_content_types.freeze
       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,29 @@ 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
+      get '(*parent_iri)/action_object', to: "#{opts.fetch(:actions, 'linked_rails/actions')}/objects#show"
     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 +53,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 +63,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 +81,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 +102,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.ld[:supplant]
+            )
+          ]
+        end
+      end
+    end
+  end
+end