linked_rails 0.0.3 → 0.0.4.pre.g3e8f5731a

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

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/storage.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require 'redis'
+
+module LinkedRails
+  class Storage
+    REDIS_DB = {
+      cache: LinkedRails.cache_redis_database,
+      persistent: LinkedRails.persistent_redis_database,
+      stream: LinkedRails.stream_redis_database
+    }.freeze
+    KEYS = {
+      manifest: 'cache:Manifest',
+      redirect_exact: 'cache:Redirect:Exact',
+      redirect_prefix: 'cache:Redirect:Prefix'
+    }.freeze
+
+    class << self
+      %i[xadd].each do |method|
+        define_method(method) do |db, *args|
+          Redis.new(db: REDIS_DB.fetch(db)).send(method, *args)
+        end
+      end
+
+      %i[hset hdel hget].each do |method|
+        define_method(method) do |db, key, *args|
+          Redis.new(db: REDIS_DB.fetch(db)).send(method, KEYS.fetch(key), *args)
+        end
+      end
+    end
+  end
+end

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/url.rb

@@ -0,0 +1,11 @@
+module LinkedRails
+  class URL
+    class << self
+      def as_href(url)
+        uri = URI(url)
+        uri.path = uri.path.presence || '/'
+        uri.to_s
+      end
+    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#')