linked_rails 0.0.1

data/lib/linked_rails/rdf_error.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module LinkedRails
+  class RDFError
+    include ActiveModel::Model
+
+    attr_accessor :error, :iri, :status
+    delegate :message, to: :error
+
+    def initialize(status, requested_url, original_error)
+      self.status = status
+      self.error = original_error.is_a?(StandardError) ? original_error : original_error.new
+      self.iri = ::RDF::URI(requested_url)
+    end
+
+    def graph # rubocop:disable Metrics/AbcSize
+      g = ::RDF::Graph.new
+      g << [iri, Vocab.schema.name, title] if title
+      g << [iri, Vocab.schema.text, message]
+      g << [iri, Vocab.rdfv.type, rdf_type]
+      g
+    end
+
+    def title
+      @title ||= I18n.t('linked_rails.status')[status] || I18n.t('linked_rails.status')[500]
+    end
+
+    def rdf_type
+      @rdf_type ||= Vocab.ontola["errors/#{error.class.name.demodulize}Error"]
+    end
+
+    def self.serializer_class
+      RDFErrorSerializer
+    end
+  end
+end

data/lib/linked_rails/renderers.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require 'rdf/serializers/renderers'
+require 'rdf/nquads'
+require 'rdf/ntriples'
+
+module LinkedRails
+  class Renderers
+    class << self
+      attr_accessor :rdf_content_types
+
+      # Registers mime types and renderers for all available rdf formats.
+      # Add additional formats by adding the gems to the Gemfile.
+      # See https://github.com/ruby-rdf/rdf#rdf-serialization-formats for a list of available formats.
+      def register!
+        self.rdf_content_types = []
+        RDF::Format.each do |format|
+          register_renderer(format.file_extension, format.content_type, format.symbols.first)
+        end
+
+        register_renderer(%i[hndjson], ['application/hex+x-ndjson'], :hndjson)
+        rdf_content_types.freeze
+      end
+
+      private
+
+      def prefixes
+        @prefixes ||=
+          RDF::Vocabulary.vocab_map.transform_values do |options|
+            options[:class] || RDF::Vocabulary.from_sym(options[:class_name])
+          end
+      end
+
+      def register_renderer(extensions, content_types, symbol)
+        return if extensions.blank? || content_types.blank? || symbol.blank?
+
+        rdf_content_types << symbol
+        Mime::Type.register(content_types.first, symbol, content_types.drop(1), extensions - [symbol])
+
+        extensions.each do |_extension|
+          RDF::Serializers::Renderers.add_renderer(symbol, content_types.first, symbol, prefixes: prefixes)
+        end
+      end
+    end
+  end
+end

data/lib/linked_rails/routes.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+require 'linked_rails/constraints/whitelist'
+
+module LinkedRails
+  module Routes
+    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
+      get '/c_a', to: "#{opts.fetch(:current_user, 'linked_rails/current_user')}#show"
+      get '/ns/core', to: "#{opts.fetch(:ontologies, 'linked_rails/ontologies')}#show"
+      get '/manifest', to: "#{opts.fetch(:manifests, 'linked_rails/manifests')}#show"
+      get '/enums/:klass/:attribute', to: "#{opts.fetch(:enum_values, 'linked_rails/enum_values')}#index"
+      get '/enums/*module/:klass/:attribute', to: "#{opts.fetch(:enum_values, 'linked_rails/enum_values')}#index"
+      get '/forms/:id', to: "#{opts.fetch(:forms, 'linked_rails/forms')}#show"
+      get '/forms/*module/:id', to: "#{opts.fetch(:forms, 'linked_rails/forms')}#show"
+
+      get '(*parent_iri)/menus', to: "#{opts.fetch(:menus, 'linked_rails/menus')}/lists#index"
+      get '(*parent_iri)/menus/:id', to: "#{opts.fetch(:menus, 'linked_rails/menus')}/lists#show"
+      get '(*parent_iri)/menu_items', to: "#{opts.fetch(:menus, 'linked_rails/menus')}/items#index"
+
+      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
+    end
+
+    def linked_resource(klass, controller: nil, nested: false, &block)
+      options = route_options(klass, controller, nested, klass.route_key)
+
+      resources(
+        options[:route_name],
+        active_controller_opts(options),
+        &route_block(klass, &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)
+      options = route_options(klass, controller, nested, klass.singular_route_key)
+
+      resource(
+        options[:route_name],
+        active_controller_opts(options).merge(singular_route: true),
+        &route_block(klass, &block)
+      )
+
+      post(options[:parentable_path], to: "#{options[:controller]}#create", singular_route: true) if options[:creatable]
+    end
+
+    def find_tenant_route
+      get '_public/spi/find_tenant', to: 'linked_rails/manifests#tenant'
+    end
+
+    private
+
+    def active_controller_opts(route_options)
+      {
+        controller: route_options[:controller],
+        only: %i[show],
+        path: route_options[:nested] ? route_options[:parentable_path] : route_options[:path]
+      }
+    end
+
+    def creatable(klass)
+      klass.enhanced_with?(LinkedRails::Enhancements::Creatable, :Routing)
+    end
+
+    def route_block(klass)
+      lambda do
+        include_route_concerns(klass: klass)
+
+        yield if block_given?
+      end
+    end
+
+    def route_options(klass, controller, nested, path)
+      {
+        controller: controller || klass.name.tableize,
+        creatable: creatable(klass),
+        nested: nested,
+        only: %i[show],
+        parentable_path: "(*parent_iri)/#{path}",
+        path: path,
+        route_name: klass.name.demodulize.tableize
+      }.with_indifferent_access
+    end
+  end
+end
+
+ActionDispatch::Routing::Mapper.include LinkedRails::Routes
+
+module LinkedRails
+  module RoutingHelper
+    def initialize(entities, api_only, shallow, options = {})
+      options[:path] ||= entities.to_s.classify.safe_constantize.try(:route_key)
+      super
+    end
+  end
+end
+
+ActionDispatch::Routing::Mapper::Resources::Resource.prepend(LinkedRails::RoutingHelper)

data/lib/linked_rails/serializer.rb

@@ -0,0 +1,137 @@
+# frozen_string_literal: true
+
+module LinkedRails
+  module Serializer
+    extend ActiveSupport::Concern
+
+    included do
+      include RDF::Serializers::ObjectSerializer
+      extend Enhanceable
+
+      enhanceable :serializable_class, :Serializer
+
+      class_attribute :_enums
+
+      set_id :iri
+
+      attribute :rdf_type, predicate: Vocab.rdfv.type, datatype: Vocab.xsd.anyURI
+      attribute :created_at, predicate: Vocab.schema[:dateCreated] do |object|
+        object.try(:created_at)
+      end
+    end
+
+    module ClassMethods
+      def anonymous_object?(object)
+        object.iri.anonymous?
+      end
+
+      def enum(attr, opts = nil)
+        self._enums ||= HashWithIndifferentAccess.new
+        opts[:type] ||= Vocab.ontola[:FormOption]
+        opts[:options] ||= default_enum_opts(attr)
+        self._enums[attr] = enum_values(attr, opts)
+
+        attribute(attr, if: opts[:if], predicate: opts[:predicate]) do |object, params|
+          block_given? ? yield(object, params) : enum_value(attr, object)
+        end
+      end
+
+      def enum_options(key)
+        _enums && _enums[key]
+      end
+
+      def enum_value(key, object)
+        options = enum_options(key)
+        return if options.blank?
+
+        raw_value = object.send(key)
+
+        options[raw_value].try(:iri) if raw_value.present?
+      end
+
+      def default_enum_opts(attr)
+        enum_opts = serializable_class.try(:defined_enums).try(:[], attr.to_s)
+        return [] if enum_opts.blank?
+
+        HashWithIndifferentAccess[
+          enum_opts&.map { |k, _v| [k.to_sym, {}] }
+        ]
+      end
+
+      # rubocop:disable Naming/PredicateName
+      def has_one(key, opts = {})
+        opts[:id_method_name] = :iri
+
+        return super if block_given?
+
+        super do |object|
+          object.send(key)
+        end
+      end
+
+      def has_many(key, opts = {})
+        opts[:id_method_name] = :iri
+
+        return super if block_given?
+
+        super do |object|
+          object.send(key)
+        end
+      end
+      # rubocop:enable Naming/PredicateName
+
+      def named_object?(object)
+        !object.iri.anonymous?
+      end
+
+      def never(_object, _params)
+        false
+      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)
+          RDF::URI(obj.to_s.gsub(/^fa-/, 'http://fontawesome.io/icon/'))
+        else
+          obj.presence
+        end
+      end
+
+      def with_collection(name, opts = {})
+        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)
+        end
+      end
+
+      private
+
+      def enum_values(attr, opts) # rubocop:disable Metrics/MethodLength
+        Hash[
+          opts[:options].map do |option_key, option_values|
+            [
+              option_key,
+              LinkedRails::EnumValue.new(
+                {
+                  key: option_key,
+                  attr: attr,
+                  klass: serializable_class,
+                  type: opts[:type]
+                }.merge(option_values)
+              )
+            ]
+          end
+        ]
+      end
+    end
+  end
+end

data/lib/linked_rails/translate.rb

@@ -0,0 +1,176 @@
+# frozen_string_literal: true
+
+module LinkedRails # rubocop:disable Metrics/ModuleLength
+  def self.translate(*args)
+    Translate.call(*args)
+  end
+
+  def self.translations(translation)
+    I18n.available_locales.map do |locale|
+      I18n.with_locale(locale) do
+        value = translation.call
+        RDF::Literal.new(value, language: locale) if value
+      end
+    end.compact
+  end
+
+  class Translate
+    cattr_accessor :strategies, default: {}
+
+    class << self
+      def call(type, key, object, fallback = true)
+        strategy_for(type, key).call(object, fallback)
+      end
+
+      def translation_key(resource)
+        klass =
+          case resource
+          when Collection
+            resource.association_class
+          when Class
+            resource
+          else
+            resource&.class
+          end
+        klass&.name&.demodulize&.tableize
+      end
+
+      def translations_for(type, key)
+        strategies[type] ||= {}
+        strategies[type][key] = ->(object, fallback) { yield(object, fallback) }
+      end
+
+      def key_for_iri(iri, key)
+        [
+          Vocab.for!(iri).__prefix__,
+          tag_for_iri(iri),
+          key
+        ].join('.')
+      end
+
+      def tag_for_iri(iri)
+        iri.to_s.split(Vocab.for(iri).to_s).last
+      end
+
+      private
+
+      def strategy_for(type, key)
+        strategies[type] ||= {}
+        strategies[type][key]
+      end
+    end
+  end
+
+  Translate.translations_for(:action, :description) do |object, fallback|
+    I18n.t(
+      "actions.#{Translate.translation_key(object)}.#{object.tag}.description",
+      default: [
+        :"actions.default.#{object.tag}.description",
+        fallback ? object.tag.to_s.humanize : ''
+      ]
+    )
+  end
+
+  Translate.translations_for(:action, :label) do |object, fallback|
+    I18n.t(
+      "actions.#{Translate.translation_key(object)}.#{object.tag}.label",
+      default: [
+        :"actions.default.#{object.tag}.label",
+        fallback ? object.tag.to_s.humanize : ''
+      ]
+    )
+  end
+
+  Translate.translations_for(:action, :submit) do |object, fallback|
+    I18n.t(
+      "actions.#{Translate.translation_key(object)}.#{object.tag}.submit",
+      default: [
+        :"actions.default.#{object.tag}.submit",
+        fallback ? object.tag.to_s.humanize : ''
+      ]
+    )
+  end
+
+  Translate.translations_for(:enum, :label) do |object|
+    I18n.t(
+      "enums.#{Translate.translation_key(object)}.#{object.attr}.#{object.key}",
+      default: [
+        :"enums.#{object.attr}.#{object.key}",
+        object.key.to_s.humanize
+      ]
+    )
+  end
+
+  Translate.translations_for(:field, :description) do |object, fallback|
+    if object.model_attribute.present?
+      I18n.t(
+        "forms.#{Translate.translation_key(object.model_class)}.#{object.model_attribute}.description",
+        default: [
+          :"forms.default.#{object.model_attribute}.description",
+          fallback ? object.model_attribute.to_s.humanize : ''
+        ]
+      ).presence
+    end
+  end
+
+  Translate.translations_for(:field, :helper_text) do |object, fallback|
+    if object.model_attribute.present?
+      I18n.t(
+        "forms.#{Translate.translation_key(object.model_class)}.#{object.model_attribute}.helper_text",
+        default: [
+          :"forms.default.#{object.model_attribute}.helper_text",
+          fallback ? object.model_attribute.to_s.humanize : ''
+        ]
+      )
+    end
+  end
+
+  Translate.translations_for(:field, :label) do |object, fallback|
+    if object.model_attribute.present?
+      I18n.t(
+        "forms.#{Translate.translation_key(object.model_class)}.#{object.model_attribute}.label",
+        default: [
+          :"forms.default.#{object.model_attribute}.label",
+          fallback ? object.model_attribute.to_s.humanize : ''
+        ]
+      ).presence
+    end
+  end
+
+  Translate.translations_for(:class, :description) do |object|
+    I18n.t(Translate.key_for_iri(object, :description), default: nil)
+  end
+
+  Translate.translations_for(:class, :icon) do |object|
+    I18n.t(Translate.key_for_iri(object, :icon), default: nil)
+  end
+
+  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
+    )
+  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
+    )
+  end
+
+  Translate.translations_for(:property, :description) do |object|
+    I18n.t(Translate.key_for_iri(object, :description), default: nil)
+  end
+
+  Translate.translations_for(:property, :icon) do |object|
+    I18n.t(Translate.key_for_iri(object, :icon), default: nil)
+  end
+
+  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
+    )
+  end
+end