linked_rails 0.0.1 → 0.0.4.pre.g1faca9643

data/lib/linked_rails/model/serialization.rb

@@ -16,19 +16,6 @@ module LinkedRails
       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
@@ -68,7 +55,7 @@ module LinkedRails
           serializer
             .attributes_to_serialize
             .values
-            .select { |attr| attr.predicate.present? }
+            .select { |attr| attr.predicate.present? && !attr.predicate.is_a?(Proc) }
             .map { |attr| [attr.predicate, attr] }
         end
 
@@ -79,7 +66,7 @@ module LinkedRails
           serializer
             .relationships_to_serialize
             .values
-            .select { |value| value.predicate.present? }
+            .select { |value| value.predicate.present? && !value.predicate.is_a?(Proc) }
             .map { |value| [value.predicate, value] }
         end
       end

data/lib/linked_rails/model/singularable.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module LinkedRails
+  module Model
+    module Singularable
+      extend ActiveSupport::Concern
+
+      included do
+        attr_accessor :singular_resource
+      end
+
+      def root_relative_singular_iri(**opts)
+        RDF::URI(singular_iri_template.expand(singular_iri_opts.merge(opts)))
+      end
+
+      def root_relative_iri(**opts)
+        return super unless singular_iri?
+
+        root_relative_singular_iri(**opts)
+      end
+
+      def singular_iri(**opts)
+        return iri_with_root(root_relative_singular_iri(**opts)) if opts.present?
+
+        @singular_iri ||= iri_with_root(root_relative_singular_iri)
+      end
+
+      def singular_iri?
+        anonymous_iri?
+      end
+
+      def singular_iri_opts
+        {}
+      end
+
+      def singular_iri_template
+        self.class.singular_iri_template
+      end
+
+      def singular_resource?
+        singular_resource || false
+      end
+
+      class_methods do
+        delegate :singular_route_key, to: :model_name
+
+        def requested_singular_resource(_params, _user_context)
+          raise(NotImplementedError)
+        end
+
+        def singular_iri_template
+          @singular_iri_template ||= LinkedRails::URITemplate.new("{/parent_iri*}/#{singular_route_key}{#fragment}")
+        end
+      end
+    end
+  end
+end

data/lib/linked_rails/model/sorting.rb

@@ -5,11 +5,6 @@ module LinkedRails
     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

data/lib/linked_rails/model/tables.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module LinkedRails
+  module Model
+    module Tables
+      extend ActiveSupport::Concern
+
+      included do
+        class_attribute :defined_columns
+      end
+
+      module ClassMethods
+        def with_columns(opts)
+          initialize_columns
+          defined_columns.merge!(opts)
+        end
+
+        def initialize_columns
+          return if defined_columns && method(:defined_columns).owner == singleton_class
+
+          self.defined_columns = superclass.try(:defined_columns)&.dup || {}.with_indifferent_access
+        end
+      end
+    end
+  end
+end

data/lib/linked_rails/model.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative 'model/actionable'
+require_relative 'model/cacheable'
 require_relative 'model/collections'
 require_relative 'model/dirty'
 require_relative 'model/enhancements'
@@ -7,33 +9,42 @@ require_relative 'model/filtering'
 require_relative 'model/indexable'
 require_relative 'model/iri'
 require_relative 'model/iri_mapping'
+require_relative 'model/menuable'
 require_relative 'model/serialization'
+require_relative 'model/singularable'
 require_relative 'model/sorting'
+require_relative 'model/tables'
 
 module LinkedRails
   module Model
     extend ActiveSupport::Concern
+    include Actionable
     include Collections
     include Dirty
     include Enhancements
     include Filtering
     include Indexable
-    include Iri
-    include IriMapping
+    include IRI
+    include IRIMapping
+    include Menuable
     include Serialization
+    include Singularable
     include Sorting
+    include Tables
 
     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))
+        raise(ActiveRecord::RecordNotFound) if try(:abstract_class?)
+
+        new(**attributes_for_new(parent: parent, user_context: user_context))
+      end
+
+      def controller_class
+        @controller_class ||= "#{to_s.pluralize}Controller".safe_constantize || superclass.try(:controller_class)
       end
 
       def form_class

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,18 @@ 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 public_resource?
+      false
+    end
+
     def show?
       false
     end
@@ -64,25 +76,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 +137,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 +161,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