linked_rails 0.0.1

data/app/models/linked_rails/manifest.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+module LinkedRails
+  class Manifest
+    include ActiveModel::Model
+    include LinkedRails::Model
+
+    def app_name
+      Rails.application.railtie_name.chomp('_application').humanize
+    end
+
+    def app_theme_color
+      '#cc0000'
+    end
+
+    def background_color
+      '#eef0f2'
+    end
+
+    def css_class; end
+
+    def header_background
+      :primary
+    end
+
+    def header_text
+      :white
+    end
+
+    def preload_iris
+      [
+        scope,
+        LinkedRails.iri(path: 'ns/core').to_s,
+        LinkedRails.iri(path: 'c_a').to_s,
+        LinkedRails.iri(path: 'menus').to_s
+      ]
+    end
+
+    def scope
+      @scope ||= LinkedRails.iri.to_s
+    end
+
+    def site_theme_color
+      app_theme_color
+    end
+
+    def site_secondary_color
+      '#262626'
+    end
+
+    def site_name
+      app_name
+    end
+
+    def theme; end
+
+    def theme_options
+      {}
+    end
+
+    def web_manifest
+      web_manifest_base.merge(
+        ontola: web_manifest_ontola_section,
+        serviceworker: web_manifest_sw_section
+      )
+    end
+
+    def web_manifest_base # rubocop:disable Metrics/MethodLength
+      {
+        background_color: background_color,
+        dir: :rtl,
+        display: :standalone,
+        lang: :nl,
+        name: app_name,
+        scope: scope,
+        short_name: app_name,
+        start_url: scope,
+        theme_color: site_theme_color
+      }
+    end
+
+    def web_manifest_ontola_section
+      {
+        css_class: css_class,
+        header_background: header_background,
+        header_text: header_text,
+        preload: preload_iris,
+        primary_color: site_theme_color,
+        secondary_color: site_secondary_color,
+        theme: theme,
+        theme_options: theme_options.to_query
+      }
+    end
+
+    def web_manifest_sw_section
+      {
+        src: "#{scope}/sw.js?manifestLocation=#{Rack::Utils.escape("#{scope}/manifest.json")}",
+        scope: scope
+      }
+    end
+  end
+end

data/app/models/linked_rails/media_object.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module LinkedRails
+  class MediaObject < Resource
+    attr_accessor :content_type, :description, :filename, :position_y, :uploaded_at
+    attr_writer :type
+
+    %i[content_url embed_url thumbnail_url url cover_url].each do |attr|
+      attr_reader attr
+
+      define_method "#{attr}=" do |value|
+        instance_variable_set("@#{attr}", value.is_a?(RDF::URI) ? value : RDF::URI(value))
+      end
+    end
+
+    def rdf_type
+      case type&.to_sym
+      when :image
+        Vocab.schema.ImageObject
+      when :video
+        Vocab.schema.VideoObject
+      else
+        Vocab.schema.MediaObject
+      end
+    end
+
+    def type
+      @type ||= content_type&.split('/')&.first
+    end
+  end
+end

data/app/models/linked_rails/menus/item.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module LinkedRails
+  module Menus
+    class Item
+      include ActiveModel::Model
+      include LinkedRails::Model
+      include LinkedRails::CallableVariable
+
+      attr_accessor :parent, :tag, :item_type, :type, :resource
+      attr_writer :action, :href, :image, :iri_base, :label, :menus
+      delegate :iri_opts, to: :parent
+
+      alias id iri
+      %i[action href image label menus iri_base].each do |method|
+        callable_variable(method, instance: :parent)
+      end
+
+      def iri_opts
+        parent.iri_opts.merge(
+          tag: route_tag,
+          fragment: route_fragment
+        )
+      end
+
+      def iri_template
+        return parent.send(:iri_template) unless parent.is_a?(LinkedRails::Menus::List)
+
+        return URITemplate.new("#{iri_base}{/tag}{#fragment}") if iri_base
+
+        iri_template_expand_path(parent.send(:iri_template), '{/tag}')
+      end
+
+      def menu_sequence
+        return if @menus.nil?
+
+        @menu_sequence ||=
+          LinkedRails::Sequence.new(
+            -> { menus&.compact&.each { |menu| menu.parent = self } },
+            id: menu_sequence_iri,
+            parent: self,
+            scope: false
+          )
+      end
+
+      def menu_sequence_iri
+        return @menu_sequence_iri if @menu_sequence_iri
+
+        sequence_iri = iri.dup
+        sequence_iri.path ||= ''
+        sequence_iri.path += '/menu_items'
+        sequence_iri
+      end
+
+      def rdf_type
+        type || Vocab.ontola[:MenuItem]
+      end
+
+      def route_fragment
+        return if parent.is_a?(LinkedRails::Menus::List)
+
+        [parent.route_fragment, tag].compact.join('.')
+      end
+
+      def route_tag
+        parent.is_a?(LinkedRails::Menus::List) ? tag : parent.route_tag
+      end
+
+      class << self
+        def base_includes
+          [action: :target]
+        end
+
+        def preview_includes
+          base_includes + [
+            menu_sequence: [
+              members: base_includes +
+                [menu_sequence: [members: base_includes]]
+            ]
+          ]
+        end
+
+        def requested_index_resource(params, user_context)
+          parent = parent_from_params(params, user_context)
+          return if parent.blank?
+
+          parent.menu_sequence
+        end
+      end
+    end
+  end
+end

data/app/models/linked_rails/menus/list.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+module LinkedRails
+  module Menus
+    class List
+      include ActiveModel::Model
+      include LinkedRails::Model
+
+      attr_accessor :resource, :user_context
+      class_attribute :_defined_menus, instance_reader: false, instance_writer: false
+
+      def available_menus
+        return {} if defined_menus.blank?
+
+        @available_menus ||= defined_menus.select(&method(:menu_available?)).compact
+      end
+
+      def defined_menus
+        self.class.defined_menus
+      end
+
+      def iri_opts
+        resource&.iri_opts || {}
+      end
+
+      def menus
+        @menus ||= available_menus.map(&method(:menu_item))
+      end
+
+      def menu(tag)
+        menu_item(tag, available_menus[tag].dup) if available_menus.key?(tag)
+      end
+
+      private
+
+      def default_label(tag, options)
+        I18n.t("menus.#{resource&.class&.name&.tableize}.#{tag}", options[:label_params])
+      end
+
+      def menu_available?(_tag, options)
+        options[:condition].nil? || call_option(options[:condition], resource)
+      end
+
+      def menu_item(tag, options) # rubocop:disable Metrics/AbcSize
+        if options[:policy].present?
+          return unless resource_policy(options[:policy_resource]).send(options[:policy], *options[:policy_arguments])
+        end
+        options[:label_params] ||= {}
+        options[:label_params][:default] ||= ["menus.default.#{tag}".to_sym, tag.to_s.capitalize]
+        options[:label] ||= default_label(tag, options)
+        options.except!(:policy_resource, :policy, :policy_arguments, :label_params)
+        LinkedRails.menus_item_class.new(resource: resource, tag: tag, parent: self, **options)
+      end
+
+      def resource_policy(policy_resource)
+        policy_resource ||= resource
+        policy_resource = instance_exec(&policy_resource) if policy_resource.respond_to?(:call)
+        raise 'policy_resource is missing' if policy_resource.blank?
+
+        @resource_policy ||= {}
+        @resource_policy[policy_resource] ||= Pundit.policy(user_context, policy_resource)
+      end
+
+      def iri_template
+        @iri_template ||= iri_template_expand_path(resource.send(:iri_template), '/menus')
+      end
+
+      class << self
+        def app_menu_list_class
+          return @app_menu_list_class if instance_variables.include?(:@app_menu_list_class)
+
+          @app_menu_list_class = 'AppMenuList'.safe_constantize
+        end
+
+        def app_menu_list(user_context)
+          app_menu_list_class&.new(
+            resource: nil,
+            user_context: user_context
+          )
+        end
+
+        def all
+          []
+        end
+
+        def defined_menus
+          initialize_menus
+          _defined_menus || {}
+        end
+
+        def has_menu(tag, opts = {}) # rubocop:disable Naming/PredicateName
+          defined_menus[tag] = opts
+        end
+
+        def requested_index_resource(params, user_context)
+          menu_list = menu_list_from_params(params, user_context)
+
+          return if menu_list.blank?
+
+          LinkedRails::Sequence.new(
+            menu_list.menus,
+            id: menu_list.iri,
+            member_includes: Item.preview_includes,
+            scope: false
+          )
+        end
+
+        def requested_single_resource(params, user_context)
+          return nil if params[:id].blank?
+
+          menu_list = menu_list_from_params(params, user_context)
+
+          menu_list&.menu(params[:id].to_sym)
+        end
+
+        private
+
+        def initialize_menus
+          return if _defined_menus && method(:_defined_menus).owner == singleton_class
+
+          self._defined_menus = superclass.try(:_defined_menus)&.dup || {}
+        end
+
+        def menu_list_from_params(params, user_context)
+          parent = parent_from_params(params, user_context)
+
+          if parent.is_a?(LinkedRails.menus_item_class)
+            parent
+          elsif parent
+            parent.menu_list(user_context)
+          else
+            app_menu_list(user_context)
+          end
+        end
+      end
+    end
+  end
+end

data/app/models/linked_rails/ontology/base.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module LinkedRails
+  class Ontology
+    class Base
+      include ActiveModel::Model
+      include LinkedRails::Model
+      attr_accessor :iri
+
+      def data
+        data = []
+        iri.each_statement do |statement|
+          next unless include_data_statement?(statement)
+
+          statement.graph_name = ::RDF::Serializers.config.default_graph
+          data << statement
+        end
+        data
+      end
+
+      def description
+        @description ||= LinkedRails.translations(
+          -> { LinkedRails.translate(self.class.translation_key, :description, iri) }
+        )
+      end
+
+      def image
+        @image ||= RDF::URI("http://fontawesome.io/icon/#{icon}") if icon
+      end
+
+      def label
+        @label ||= LinkedRails.translations(
+          -> { LinkedRails.translate(self.class.translation_key, :label, iri) }
+        )
+      end
+
+      private
+
+      def icon
+        @icon ||= LinkedRails.translate(self.class.translation_key, :icon, iri)
+      end
+
+      def include_data_statement?(statement)
+        statement.predicate != Vocab.rdfs.label &&
+          statement.predicate != Vocab.rdfs.range &&
+          statement.predicate != Vocab.rdfs.domain
+      end
+    end
+  end
+end

data/app/models/linked_rails/ontology/class.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require_relative './base'
+
+module LinkedRails
+  class Ontology
+    class Class < Base
+      attr_accessor :klass
+
+      def input_select_property
+        klass.try(:input_select_property)
+      end
+
+      def parent_class
+        if klass.superclass == ApplicationRecord
+          Vocab.schema.Thing
+        else
+          klass.superclass.iri
+        end
+      end
+
+      def plural_label
+        @plural_label ||= LinkedRails.translations(
+          -> { LinkedRails.translate(self.class.translation_key, :plural_label, iri) }
+        )
+      end
+
+      def properties
+        @properties ||= klass.predicate_mapping.keys.map { |key| LinkedRails.ontology_property_class.new(iri: key) }
+      end
+
+      class << self
+        def iri
+          Vocab.rdfs.Class
+        end
+
+        def translation_key
+          :class
+        end
+      end
+    end
+  end
+end