linked_rails 0.0.1

data/lib/linked_rails/model/iri_mapping.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module LinkedRails
+  module Model
+    module IriMapping
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+        def parent_from_params(params, user_context)
+          LinkedRails.iri_mapper.parent_from_params(params, 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))
+          end
+        end
+
+        def requested_index_resource!(params, user_context)
+          requested_index_resource(params, user_context) || raise(ActiveRecord::RecordNotFound)
+        end
+
+        def requested_resource(opts, user_context)
+          if collection_action?(opts)
+            requested_index_resource(opts[:params], user_context)
+          elsif singular_action?(opts)
+            resource = requested_singular_resource(opts[:params], user_context)
+            resource&.singular_resource = true
+            resource
+          else
+            requested_single_resource(opts[:params], user_context)
+          end
+        end
+
+        def requested_single_resource(params, _user_context)
+          if self < ActiveRecord::Base
+            find_by(primary_key => params[:id]) if params.key?(:id)
+          else
+            new(params)
+          end
+        end
+
+        def requested_single_resource!(params, user_context)
+          requested_single_resource(params, user_context) || raise(ActiveRecord::RecordNotFound)
+        end
+
+        private
+
+        def collection_action?(opts)
+          %w[index create].include?(opts[:action]) && !opts[:params][:singular_route]
+        end
+
+        def index_collection_params(params, user_context)
+          params_hash = params.is_a?(ActionController::Parameters) ? params.to_unsafe_h : params
+
+          {
+            user_context: user_context
+          }.merge(params_hash).with_indifferent_access
+        end
+
+        def singular_action?(opts)
+          opts[:params][:singular_route]
+        end
+      end
+    end
+  end
+end

data/lib/linked_rails/model/serialization.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module LinkedRails
+  module Model
+    module Serialization
+      extend ActiveSupport::Concern
+
+      alias read_attribute_for_serialization send
+
+      def preview_includes
+        self.class.preview_includes
+      end
+
+      def show_includes
+        preview_includes
+      end
+
+      module ClassMethods
+        def attributes_from_filters(filters)
+          filters.each_with_object({}) do |(key, value), hash|
+            next unless value.count == 1
+
+            attribute = predicate_mapping[key]&.key
+            hash[attribute] = value.first if attribute
+          end
+        end
+
+        def include_in_collection?
+          false
+        end
+
+        def input_select_property
+          Vocab.schema.name
+        end
+
+        # The associations to preload when serializing multiple records
+        def includes_for_serializer
+          {}
+        end
+
+        def predicate_for_key(key)
+          return if key.blank?
+
+          predicate_mapping.detect { |_key, value| value.key.to_sym == key.to_sym }&.first ||
+            predicate_for_key(try(:attribute_aliases)&.key(key.to_s))
+        end
+
+        def predicate_mapping
+          @predicate_mapping ||= Hash[attribute_mapping + reflection_mapping]
+        end
+
+        # The associations to include when serializing multiple records
+        def preview_includes
+          []
+        end
+
+        # The associations to include when serializing one record
+        def show_includes
+          preview_includes
+        end
+
+        private
+
+        def attribute_mapping
+          serializer = RDF::Serializers.serializer_for(self)
+          return [] if serializer.try(:attributes_to_serialize).blank?
+
+          serializer
+            .attributes_to_serialize
+            .values
+            .select { |attr| attr.predicate.present? }
+            .map { |attr| [attr.predicate, attr] }
+        end
+
+        def reflection_mapping
+          serializer = RDF::Serializers.serializer_for(self)
+          return [] if serializer.try(:relationships_to_serialize).blank?
+
+          serializer
+            .relationships_to_serialize
+            .values
+            .select { |value| value.predicate.present? }
+            .map { |value| [value.predicate, value] }
+        end
+      end
+    end
+  end
+end

data/lib/linked_rails/model/sorting.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module LinkedRails
+  module Model
+    module Sorting
+      extend ActiveSupport::Concern
+
+      included do
+        class_attribute :default_sortings, instance_accessor: false, instance_predicate: false
+        self.default_sortings = [{key: Vocab.schema.dateCreated, direction: :desc}]
+      end
+
+      module ClassMethods
+        def default_sort_column
+          :created_at
+        end
+      end
+    end
+  end
+end

data/lib/linked_rails/model.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require_relative 'model/collections'
+require_relative 'model/dirty'
+require_relative 'model/enhancements'
+require_relative 'model/filtering'
+require_relative 'model/indexable'
+require_relative 'model/iri'
+require_relative 'model/iri_mapping'
+require_relative 'model/serialization'
+require_relative 'model/sorting'
+
+module LinkedRails
+  module Model
+    extend ActiveSupport::Concern
+    include Collections
+    include Dirty
+    include Enhancements
+    include Filtering
+    include Indexable
+    include Iri
+    include IriMapping
+    include Serialization
+    include Sorting
+
+    def build_child(klass, user_context: nil)
+      klass.build_new(parent: self, user_context: user_context)
+    end
+
+    def singular_resource?
+      false
+    end
+
+    module ClassMethods
+      def build_new(parent: nil, user_context: nil)
+        new(attributes_for_new(parent: parent, user_context: user_context))
+      end
+
+      def form_class
+        @form_class ||= "#{name}Form".safe_constantize || superclass.try(:form_class)
+      end
+
+      def label
+        obj = iri.is_a?(Array) ? iri.first : iri
+        LinkedRails.translate(:class, :label, obj) if obj
+      end
+
+      def plural_label
+        obj = iri.is_a?(Array) ? iri.first : iri
+        LinkedRails.translate(:class, :plural_label, obj) if obj
+      end
+
+      def policy_class
+        @policy_class ||= "#{name}Policy".safe_constantize || superclass.try(:policy_class)
+      end
+
+      private
+
+      def attribute_from_filter(filter, predicate)
+        filter[predicate]&.first if filter
+      end
+
+      def attributes_for_new(_opts)
+        {}
+      end
+    end
+  end
+end

data/lib/linked_rails/params_parser.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+module LinkedRails
+  class ParamsParser
+    attr_reader :params, :user_context
+
+    def initialize(params)
+      @user_context = params[:user_context]
+      @params = params.is_a?(Hash) ? ActionController::Parameters.new(params) : params
+    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?
+
+      @before_params = values.map do |f|
+        key, value = f.split('=')
+        {key: RDF::URI(CGI.unescape(key)), value: value}
+      end
+    end
+
+    def collection_params
+      return @collection_params if instance_variable_defined?(:@collection_params)
+
+      values = permit_params(:display, :page_size, :title, :type)
+
+      filter = filter_params
+      values[:filter] = filter if filter
+
+      sort = sorting_params
+      values[:sort] = sort if sort
+
+      values[:user_context] = user_context if user_context
+
+      @collection_params = values
+    end
+
+    def collection_view_params
+      return @collection_view_params if instance_variable_defined?(:@collection_view_params)
+
+      values = permit_params(:page)
+
+      before = before_params
+      values[:before] = before if before
+
+      @collection_view_params = values
+    end
+
+    def filter_params # rubocop:disable Metrics/AbcSize
+      return @filter_params if instance_variable_defined?(:@filter_params)
+
+      values = permit_params(filter: [])[:filter] || permit_params(filter: {})[:filter]
+      return @filter_params = values if values.is_a?(Hash)
+      return @filter_params = {} if values.blank?
+
+      @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)
+      end
+    end
+
+    def sorting_params
+      return @sorting_params if instance_variable_defined?(:@sorting_params)
+
+      values = permit_params(sort: [])[:sort]
+      return @sorting_params = nil if values.blank?
+
+      @sorting_params = values.map do |f|
+        parse_filter_value(f)
+      end
+    end
+
+    private
+
+    def parse_filter_value(value)
+      return value if value.is_a?(Hash)
+
+      key, value = value.split('=')
+      {key: RDF::URI(CGI.unescape(key)), direction: value}
+    end
+
+    def permit_params(*keys)
+      params
+        .permit(*keys)
+        .to_h
+        .with_indifferent_access
+    end
+  end
+end

data/lib/linked_rails/policy/attribute_conditions.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module LinkedRails
+  module Policy
+    module AttributeConditions
+      extend ActiveSupport::Concern
+
+      private
+
+      def check_has_properties(properties)
+        properties.all? { |k, v| @record.send(k).nil? != v }
+      end
+
+      def check_has_values(values)
+        values.all? { |k, v| @record.send(k) == v }
+      end
+
+      def check_new_record(boolean)
+        @record.new_record? == boolean
+      end
+
+      module ClassMethods
+        private
+
+        def has_properties_shapes(properties) # rubocop:disable Naming/PredicateName
+          properties.map do |key, boolean|
+            SHACL::PropertyShape.new(
+              path: policy_class.predicate_for_key(key),
+              max_count: boolean ? nil : 0,
+              min_count: boolean ? 1 : nil
+            )
+          end
+        end
+
+        def has_values_shapes(values) # rubocop:disable Naming/PredicateName
+          values.map do |key, value|
+            enum = RDF::Serializers.serializer_for(policy_class).enum_options(key).try(:[], value)
+            santized_value = enum ? -> { enum.iri } : value
+
+            SHACL::PropertyShape.new(
+              path: policy_class.predicate_for_key(key),
+              has_value: santized_value
+            )
+          end
+        end
+
+        def new_record_shapes(boolean)
+          has_properties_shapes(created_at: !boolean)
+        end
+      end
+    end
+  end
+end

data/lib/linked_rails/policy.rb

@@ -0,0 +1,189 @@
+# frozen_string_literal: true
+
+require_relative 'active_response/controller'
+require_relative 'controller/error_handling'
+require_relative 'policy/attribute_conditions'
+
+module LinkedRails
+  module Policy
+    extend ActiveSupport::Concern
+
+    included do
+      extend Enhanceable
+      include AttributeConditions
+
+      enhanceable :policy_class, :Policy
+      class_attribute :_permitted_attributes
+
+      attr_reader :message, :user_context, :record
+
+      def initialize(user_context, record)
+        @user_context = user_context
+        @record = record
+      end
+    end
+
+    def create_child?(klass, opts = {})
+      child_policy(klass, opts).create?
+    end
+
+    def index_children?(klass, opts = {})
+      child_policy(klass, opts).show?
+    end
+
+    def permitted_attributes
+      self.class.permitted_attributes
+        .select { |opts| attribute_permitted?(opts[:conditions]) }
+        .map { |opts| sanitized_attributes(opts[:attributes], opts[:options] || {}) }
+        .flatten
+    end
+
+    def show?
+      false
+    end
+
+    def update?
+      false
+    end
+
+    def create?
+      false
+    end
+
+    def destroy?
+      false
+    end
+
+    private
+
+    def attribute_permitted?(conditions)
+      conditions.all? do |key, opts|
+        raise "Unknown attribute condition #{key}" unless respond_to?("check_#{key}", true)
+
+        send(:"check_#{key}", opts)
+      end
+    end
+
+    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)
+      @message = message
+      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
+
+    def sanitize_attribute(attr)
+      attr
+    end
+
+    def sanitized_attributes(attributes, opts)
+      if opts[:nested]
+        attributes.map(&method(:sanitize_nested_attribute))
+      elsif opts[:array]
+        attributes.map(&method(:sanitize_array_attribute))
+      else
+        attributes.map(&method(:sanitize_attribute))
+      end
+    end
+
+    def sanitize_nested_attribute(key) # rubocop:disable Metrics/AbcSize
+      association = record.class.reflect_on_association(key)
+
+      return nil if association.blank? || (!association.polymorphic? && !association.klass)
+
+      nested_attributes =
+        if association.polymorphic?
+          Pundit.policy(user_context, record).try("#{association.name}_attributes") || []
+        else
+          child = record.build_child(association.klass, user_context: user_context)
+          Pundit.policy(user_context, child).permitted_attributes
+        end
+
+      {"#{key}_attributes" => nested_attributes + %i[id _destroy]}
+    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
+      end
+
+      def permitted_attributes
+        initialize_permitted_attributes
+
+        _permitted_attributes
+      end
+
+      private
+
+      def attribute_options(attr)
+        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 = {})
+        permitted_attributes << {attributes: attrs, conditions: conditions, options: {}}
+      end
+
+      def permit_array_attributes(attrs, conditions = {})
+        permitted_attributes << {attributes: attrs, conditions: conditions, options: {array: true}}
+      end
+
+      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
+    end
+  end
+end