linked_rails 0.0.3 → 0.0.4.pre.g2c53724b3

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
+      include Empathy::EmpJson::Serializer
       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,28 +94,36 @@ 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
 
       def serialize_image(obj)
-        if obj.is_a?(String) || obj.is_a?(Symbol)
+        if (obj.is_a?(String) || obj.is_a?(Symbol)) && !obj.to_s.include?('http')
           RDF::URI(obj.to_s.gsub(/^fa-/, 'http://fontawesome.io/icon/'))
         else
           obj.presence
         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)
+        collection_opts[:table_type] = opts.delete(:table_type) if opts.key?(:table_type)
+
+        has_one collection_name, **opts do |object, params|
+          object.send(collection_name, **collection_opts.merge(user_context: params[:scope]))
         end
       end
 
@@ -135,3 +149,6 @@ module LinkedRails
     end
   end
 end
+
+RDF::Serializers::NilSerializer.include(Empathy::EmpJson::Serializer)
+RDF::Serializers::ListSerializer.include(Empathy::EmpJson::Serializer)

data/lib/linked_rails/test_methods.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+module LinkedRails
+  module TestMethods
+    def expect_disabled_form(iri: requested_iri, error: 'This action is currently not available')
+      assert_response 200
+      expect_triple(iri, NS.schema.actionStatus, NS.ontola[:DisabledActionStatus])
+      expect_triple(iri, NS.schema.error, error) if error
+    end
+
+    def expect_enabled_form(iri: requested_iri)
+      assert_response 200
+      expect_triple(iri, NS.schema.actionStatus, NS.schema.PotentialActionStatus)
+    end
+
+    def expect_errors(iri, errors)
+      error_response = expect_triple(iri, NS.ll[:errorResponse], nil).first.object
+      assert_equal expect_triple(error_response, nil, nil).count, errors.count + 2
+      errors.each do |key, value|
+        expect_triple(error_response, key, value)
+      end
+    end
+
+    def expect_header(key, value)
+      expect(response.headers[key]).to(include(value))
+    end
+
+    def expect_ontola_action(redirect: nil, snackbar: nil, reload: nil)
+      if redirect
+        expect_header('Exec-Action', "actions/redirect?#{{location: redirect, reload: reload}.compact.to_param}")
+      end
+      expect_header('Exec-Action', "actions/snackbar?#{{text: snackbar}.to_param}") if snackbar
+
+      expect_ontola_action_count([redirect, snackbar].compact.size)
+    end
+
+    def expect_ontola_action_count(count)
+      if count.zero?
+        assert_nil response.headers['Exec-Action']
+      else
+        assert_equal count, response.headers['Exec-Action'].count("\n"), response.headers['Exec-Action']
+      end
+    end
+
+    # Tests if the property {path} starting at {start} resolves to {value}.
+    # If multiple solutions are present only one has to match to pass.
+    #
+    # @param [IRI] start The node to start at
+    # @param [Array] path The property path to traverse
+    # @param [IRI|IRI[]] value The value to match at the end, pass an array to
+    #                            match multiple values.
+    def expect_path(start, path, value) # rubocop:disable Metrics/AbcSize
+      match = path.each_with_index.reduce(start) do |node, (path_seg, i)|
+        obj = [*node].map { |cur_node| rdf_body.query([cur_node, path_seg, nil, nil]).map(&:object) }.flatten
+        break (obj & [*value]).present? if path.length - 1 == i
+
+        nodes = obj.filter { |o| o.is_a?(RDF::Resource) }
+        break false if nodes.blank?
+
+        nodes
+      end
+
+      segs = path.map(&:to_s).join(', ')
+      assert match,
+             "Expected to find '#{value}' from '#{start}' through '[#{segs}]' in\n#{response.body}"
+    end
+
+    def expect_resource_type(type, iri: requested_iri)
+      expect_triple(iri, RDF[:type], type)
+    end
+
+    def expect_sequence(subject, predicate)
+      expect_triple(subject, predicate, nil).first.object
+    end
+
+    def expect_sequence_member(subject, index, object)
+      expect_triple(subject, RDF[:"_#{index}"], object)
+      object
+    end
+
+    def expect_sequence_size(subject, expected_count)
+      count =
+        expect_triple(subject, nil, nil)
+          .select { |s| s.predicate.to_s.starts_with?('http://www.w3.org/1999/02/22-rdf-syntax-ns#_') }
+          .count
+      assert_equal expected_count, count
+    end
+
+    def expect_triple(subject, predicate, object, graph = NS.ll[:supplant])
+      statement = RDF::Statement(subject, predicate, object, graph_name: graph)
+      match = rdf_body.query(statement)
+      assert match.present?, "Expected to find #{statement} in\n#{response.body}"
+      match
+    end
+
+    def refute_triple(subject, predicate, object, graph = nil)
+      statement = RDF::Statement(subject, predicate, object, graph_name: graph)
+      assert_not rdf_body.query([subject, predicate, object, graph]).present?,
+                 "Expected not to find #{statement} in\n#{response.body}"
+    end
+
+    def requested_iri
+      RDF::URI(request.original_url.sub(".#{request.format.symbol}", ''))
+    end
+
+    def rdf_body
+      @rdf_body ||= RDF::Graph.new << RDF::Reader
+                                        .for(content_type: response.headers['Content-Type'])
+                                        .new(response.body)
+    end
+  end
+end
+
+ActiveSupport::TestCase.include(LinkedRails::TestMethods)

data/lib/linked_rails/translate.rb

@@ -62,28 +62,38 @@ module LinkedRails # rubocop:disable Metrics/ModuleLength
   end
 
   Translate.translations_for(:action, :description) do |object, fallback|
+    result_class = object.list.send(:result_class)
+    klass_iri = result_class.iri.is_a?(Array) ? result_class.iri.first : result_class.iri
+    type = LinkedRails.translate(:class, :label, klass_iri)&.downcase
+
     I18n.t(
-      "actions.#{Translate.translation_key(object)}.#{object.tag}.description",
+      "actions.#{Translate.translation_key(object.resource)}.#{object.tag}.description",
       default: [
         :"actions.default.#{object.tag}.description",
         fallback ? object.tag.to_s.humanize : ''
-      ]
+      ],
+      type: type
     )
   end
 
   Translate.translations_for(:action, :label) do |object, fallback|
+    result_class = object.list.send(:result_class)
+    klass_iri = result_class.iri.is_a?(Array) ? result_class.iri.first : result_class.iri
+    type = LinkedRails.translate(:class, :label, klass_iri)&.downcase
+
     I18n.t(
-      "actions.#{Translate.translation_key(object)}.#{object.tag}.label",
+      "actions.#{Translate.translation_key(object.resource)}.#{object.tag}.label",
       default: [
         :"actions.default.#{object.tag}.label",
         fallback ? object.tag.to_s.humanize : ''
-      ]
+      ],
+      type: type
     )
   end
 
   Translate.translations_for(:action, :submit) do |object, fallback|
     I18n.t(
-      "actions.#{Translate.translation_key(object)}.#{object.tag}.submit",
+      "actions.#{Translate.translation_key(object.resource)}.#{object.tag}.submit",
       default: [
         :"actions.default.#{object.tag}.submit",
         fallback ? object.tag.to_s.humanize : ''
@@ -93,7 +103,7 @@ module LinkedRails # rubocop:disable Metrics/ModuleLength
 
   Translate.translations_for(:enum, :label) do |object|
     I18n.t(
-      "enums.#{Translate.translation_key(object)}.#{object.attr}.#{object.key}",
+      "enums.#{Translate.translation_key(object.klass)}.#{object.attr}.#{object.key}",
       default: [
         :"enums.#{object.attr}.#{object.key}",
         object.key.to_s.humanize
@@ -125,6 +135,18 @@ module LinkedRails # rubocop:disable Metrics/ModuleLength
     end
   end
 
+  Translate.translations_for(:field, :placeholder) do |object, fallback|
+    if object.model_attribute.present?
+      I18n.t(
+        "forms.#{Translate.translation_key(object.model_class)}.#{object.model_attribute}.placeholder",
+        default: [
+          :"forms.default.#{object.model_attribute}.placeholder",
+          fallback ? object.model_attribute.to_s.humanize : ''
+        ]
+      )
+    end
+  end
+
   Translate.translations_for(:field, :label) do |object, fallback|
     if object.model_attribute.present?
       I18n.t(
@@ -148,14 +170,14 @@ module LinkedRails # rubocop:disable Metrics/ModuleLength
   Translate.translations_for(:class, :label) do |object|
     I18n.t(
       Translate.key_for_iri(object, :label),
-      default: (object.label || Translate.tag_for_iri(object)).to_s.underscore.humanize
+      default: (object.try(:label) || Translate.tag_for_iri(object)).to_s.underscore.humanize
     )
   end
 
   Translate.translations_for(:class, :plural_label) do |object|
     I18n.t(
       Translate.key_for_iri(object, :plural_label),
-      default: (object.label || Translate.tag_for_iri(object)).to_s.tableize.humanize
+      default: (object.try(:label) || Translate.tag_for_iri(object)).to_s.tableize.humanize
     )
   end
 
@@ -170,7 +192,7 @@ module LinkedRails # rubocop:disable Metrics/ModuleLength
   Translate.translations_for(:property, :label) do |object|
     I18n.t(
       Translate.key_for_iri(object, :label),
-      default: (object.label || Translate.tag_for_iri(object)).to_s.underscore.humanize
+      default: (object.try(:label) || Translate.tag_for_iri(object)).to_s.underscore.humanize
     )
   end
 end

data/lib/linked_rails/types/iri_type.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module LinkedRails
+  module Types
+    class IRI < ActiveRecord::Type::Value
+      def type
+        :string
+      end
+
+      def cast(value)
+        RDF::URI(value) if value.present?
+      end
+
+      def serialize(value)
+        value.to_s
+      end
+    end
+  end
+
+  module QuoteIRI
+    def quote(value)
+      return super unless value.is_a?(RDF::URI) || value.is_a?(URI)
+
+      super(value.to_s)
+    end
+
+    def type_cast(value)
+      return super unless value.is_a?(RDF::URI) || value.is_a?(URI)
+
+      super(value.to_s)
+    end
+  end
+end
+
+if ActiveRecord::ConnectionAdapters.const_defined?(:PostgreSQLAdapter)
+  ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.prepend(LinkedRails::QuoteIRI)
+end

data/lib/linked_rails/uri_template.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require 'uri_template'
+
+module LinkedRails
+  class URITemplate < URITemplate::RFC6570
+    ARRAY_SUFFIX = '%5B%5D'
+
+    private
+
+    def normalize_variables(vars)
+      variables
+        .select { |var| var.ends_with?(ARRAY_SUFFIX) }
+        .each_with_object(super.with_indifferent_access) do |var, hash|
+        key = var.sub(ARRAY_SUFFIX, '')
+        hash[var] = normalize_array_value(hash[key]) if hash.key?(key)
+      end
+    end
+
+    def normalize_array_value(original_value)
+      return original_value unless original_value.is_a?(Hash)
+
+      original_value.map do |key, values|
+        (values.is_a?(Array) ? values : [values]).map do |value|
+          "#{CGI.escape(key.to_s)}=#{value}"
+        end
+      end.flatten
+    end
+  end
+end

data/lib/linked_rails/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module LinkedRails
-  VERSION = '0.0.3'
+  VERSION = '0.0.4'
 end

data/lib/linked_rails/vocab.rb

@@ -19,6 +19,14 @@ module LinkedRails
     end
 
     class << self
+      def app_vocabulary(key)
+        vocabulary = send(key)
+
+        LinkedRails::Vocab.define_singleton_method :app do
+          vocabulary
+        end
+      end
+
       def define_shortcut(key)
         define_singleton_method(key) do
           options = RDF::Vocabulary.vocab_map.fetch(key)
@@ -74,6 +82,7 @@ module LinkedRails
     register(:fhir, 'http://hl7.org/fhir/')
     register(:form, 'https://ns.ontola.io/form#')
     register(:libro, 'https://ns.ontola.io/libro/')
+    register(:ld, 'http://purl.org/linked-delta/')
     register(:ll, 'http://purl.org/link-lib/')
     register(:ontola, 'https://ns.ontola.io/core#')
     register(:sp, 'http://spinrdf.org/sp#')

data/lib/linked_rails.rb

@@ -1,22 +1,25 @@
 # frozen_string_literal: true
 
 require 'active_response'
+require 'empathy/emp_json'
 require 'jsonapi/serializer'
 require 'kaminari/activerecord'
 require 'rdf'
+require 'rdf/list'
+require 'rdf/query_fix'
 require 'rdf/vocab'
-require 'uri_template'
 require 'nill_class_renderer'
 require 'linked_rails/engine'
 require 'linked_rails/iri_mapper'
+require 'linked_rails/collection_params_parser'
 require 'linked_rails/params_parser'
 require 'linked_rails/middleware/linked_data_params'
+require 'linked_rails/middleware/error_handling'
 require 'linked_rails/renderers'
 
 module LinkedRails
   @model_classes = {}
 
-  mattr_accessor :app_vocab, default: RDF::Vocabulary.new('http://example.com/my_vocab#')
   mattr_accessor :whitelisted_spi_ips
   mattr_writer :host, :scheme
 
@@ -37,37 +40,51 @@ module LinkedRails
       # rubocop:enable Style/ClassVars
     end
 
+    def linked_models
+      @linked_models ||= ObjectSpace.each_object(Class).select do |c|
+        c.included_modules.include?(LinkedRails::Model)
+      end
+    end
+
     def scheme
       @@scheme ||= Rails.application.routes.default_url_options[:protocol] || :http # rubocop:disable Style/ClassVars
     end
 
-    def iri(opts = {})
+    def iri(**opts)
       RDF::URI.new(**{scheme: LinkedRails.scheme, host: LinkedRails.host}.merge(opts))
     end
   end
 
-  %i[collection entry_point ontology].each { |klass| configurable_class(nil, klass) }
-  %i[filter sorting view infinite_view paginated_view].each { |klass| configurable_class(:collection, klass) }
-  configurable_class(:ontology, :class)
-  configurable_class(:ontology, :property)
   configurable_class(:actions, :item)
+  configurable_class(:collection, :filter)
+  configurable_class(:collection, :sorting)
+  configurable_class(:collection, :view)
+  configurable_class(:collection, :infinite_view)
+  configurable_class(:collection, :paginated_view)
   configurable_class(:menus, :item)
-  configurable_class(nil, :current_user)
-  configurable_class(nil, :manifest)
-  configurable_class(nil, :rdf_error, default: 'LinkedRails::RDFError')
-  configurable_class(nil, :action_list_parent, default: 'ApplicationActionList')
+  configurable_class(:ontology, :class)
+  configurable_class(:ontology, :property)
+  configurable_class(nil, :action_list_parent, default: 'LinkedRails::Actions::List')
+  configurable_class(nil, :collection)
   configurable_class(nil, :controller_parent, default: 'ApplicationController')
+  configurable_class(nil, :current_user)
+  configurable_class(nil, :entry_point)
   configurable_class(nil, :form_parent, default: 'ApplicationForm')
+  configurable_class(nil, :iri_mapper, default: 'LinkedRails::IRIMapper', reader: :iri_mapper)
+  configurable_class(nil, :manifest)
+  configurable_class(nil, :ontology)
   configurable_class(nil, :policy_parent, default: 'ApplicationPolicy')
+  configurable_class(nil, :rdf_error, default: 'LinkedRails::RDFError')
   configurable_class(nil, :serializer_parent, default: 'ApplicationSerializer')
-  configurable_class(nil, :iri_mapper, default: 'LinkedRails::IRIMapper', reader: :iri_mapper)
 end
 
 ActiveSupport::Inflector.inflections do |inflect|
+  inflect.acronym 'IRI'
   inflect.acronym 'RDF'
   inflect.acronym 'SHACL'
 end
 
+require 'linked_rails/uri_template'
 require 'linked_rails/vocab'
 require 'linked_rails/cache'
 require 'linked_rails/enhancements'
@@ -83,4 +100,4 @@ require 'linked_rails/rdf_error'
 require 'linked_rails/routes'
 require 'linked_rails/serializer'
 require 'linked_rails/translate'
-require_relative 'rails/welcome_controller'
+require 'linked_rails/railtie'

data/lib/rails/welcome_controller.rb

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
 
+require 'rails/application_controller'
+
 module Rails
-  class WelcomeController
-    include AbstractController::Callbacks
-    include ActiveResponse::Controller
+  class WelcomeController < Rails::ApplicationController
     include LinkedRails::Controller
 
     def index

data/lib/rdf/list.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module RDF
+  class List
+    def serializer_class
+      RDF::Serializers::ListSerializer
+    end
+  end
+end

data/lib/rdf/query_fix.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module QueryFix
+  def initialize(*args, **options)
+    if args.length == 1 && args.first.is_a?(String) && args.first.include?('?')
+      split_iri = args.first.split('?')
+
+      super([split_iri[0], split_iri[1]&.gsub('+', '%20')].join('?'), **options)
+    else
+      super
+    end
+  end
+end
+
+RDF::URI.prepend(QueryFix)