linked_rails 0.0.1

data/README.md

@@ -0,0 +1,65 @@
+# LinkedRails
+LinkedRails is a gem for Ruby on Rails that helps you create a Linked Data application in a matter of seconds.
+
+It includes among other things:
+* Linked data serialization to Turtle, JSON-LD, N-Triples and more using [rdf-serializers](https://github.com/ontola/rdf-serializers)
+* Controller abstraction using [active_response](https://github.com/ontola/active_response)
+* Serialization of forms
+* Serialization of collections using the [Activity Streams spec](https://www.w3.org/ns/activitystreams)
+* Serialization of menus
+* Communicating actions to be executed by the frontend using Exec Actions header
+* Rendering errors as RDF
+* Parsing linked data graphs as params
+
+## Work in progress
+This gem is an extraction from an existing app. Tests are not yet sufficient but will be extended soon.
+
+## Installation
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'linked_rails'
+```
+
+And then execute:
+```bash
+$ bundle
+```
+
+Or install it yourself as:
+```bash
+$ gem install linked_rails
+```
+
+## Getting started
+
+Add the following lines to application.rb to enable params parsing
+```
+module MyApp
+  class Application < Rails::Application
+    [...]
+    config.middleware.use LinkedRails::Middleware::LinkedDataParams
+    [...]
+  end
+end
+```
+
+Add the following line to your models
+```
+LinkedRails::Model
+```
+
+Add the following line to your controllers
+```
+LinkedRails::Controller
+```
+
+Add the following line to your serializers
+```
+LinkedRails::Serializer
+```
+
+Add the following line to your policies
+```
+LinkedRails::Policy
+```

data/Rakefile

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+require 'rdoc/task'
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'LinkedRails'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.md')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+APP_RAKEFILE = File.expand_path('spec/dummy/Rakefile', __dir__)
+load 'rails/tasks/engine.rake'
+
+load 'rails/tasks/statistics.rake'
+
+require 'bundler/gem_tasks'
+
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+task default: :test

data/app/controllers/linked_rails/actions/items_controller.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module LinkedRails
+  module Actions
+    class ItemsController < LinkedRails.controller_parent_class
+      active_response :show
+    end
+  end
+end

data/app/controllers/linked_rails/bulk_controller.rb

@@ -0,0 +1,195 @@
+# frozen_string_literal: true
+
+require 'benchmark'
+
+module LinkedRails
+  class BulkController < ApplicationController # rubocop:disable Metrics/ClassLength
+    REQUEST_HEADERS = %w[HTTP_ACCEPT_LANGUAGE HTTP_AUTHORIZATION HTTP_FORWARDED HTTP_HOST HTTP_REFERER HTTP_USER_AGENT
+                         HTTP_WEBSITE_IRI HTTP_X_DEVICE_ID HTTP_X_FORWARDED_FOR HTTP_X_FORWARDED_HOST
+                         HTTP_X_FORWARDED_PROTO HTTP_X_FORWARDED_SSL HTTP_X_REAL_IP].freeze
+
+    def show
+      render json: authorized_resources
+
+      print_timings
+    end
+
+    private
+
+    def authorized_resource(opts)
+      return response_for_wrong_host(opts) if wrong_host?(opts[:iri])
+
+      include = opts[:include].to_s == 'true'
+
+      response_from_request(include, RDF::URI(opts[:iri]))
+    rescue StandardError => e
+      handle_resource_error(opts, e)
+    end
+
+    def authorized_resources
+      @authorized_resources ||=
+        params
+          .require(:resources)
+          .map { |param| param.permit(:include, :iri) }
+          .map(&method(:timed_authorized_resource))
+    end
+
+    def handle_resource_error(opts, error)
+      log_resource_error(error)
+      status = error_status(error)
+      body = error_body(status, error, opts[:iri]) if opts[:include].to_s == 'true'
+
+      resource_response(
+        opts[:iri],
+        body: body,
+        status: status
+      )
+    end
+
+    def error_body(status, error, iri)
+      resource_body(error_resource(status, error, iri))
+    end
+
+    def log_resource_error(error)
+      return unless log_resource_error?(error)
+
+      Rails.logger.error(error)
+      Rails.logger.error(error.backtrace.join("\n"))
+    end
+
+    def log_resource_error?(error)
+      !Rails.env.production? && error_status(error) >= 500
+    end
+
+    def print_timings
+      Rails.logger.debug(
+        "\n  CPU        system     user+system real        inc   status  cache   iri\n" \
+        "#{timings.join("\n")}\n" \
+        "  User: #{current_user.class}(#{current_user.id})"
+      )
+    end
+
+    def require_doorkeeper_token?
+      false
+    end
+
+    def resource_body(resource)
+      return if resource.nil?
+
+      serializer_options = RDF::Serializers::Renderers.transform_opts(
+        {include: resource&.try(:preview_includes)},
+        serializer_params
+      )
+      RDF::Serializers.serializer_for(resource).new(resource, serializer_options).send(:render_hndjson)
+    end
+
+    def resource_response_body(iri, rack_body, status)
+      return rack_body.body if rack_body.is_a?(ActionDispatch::Response::RackBody)
+
+      error_body(status, StandardError.new(I18n.t("linked_rails.status.#{status}")), iri)
+    end
+
+    def resource_request(iri)
+      env = resource_request_env(iri)
+      req = ActionDispatch::Request.new(env)
+      req.path_info = ActionDispatch::Journey::Router::Utils.normalize_path(req.path_info)
+      req.env['Current-User'] = current_user
+      req.env['Doorkeeper-Token'] = doorkeeper_token
+
+      req
+    end
+
+    def resource_request_env(iri)
+      path = sanitized_relative_path(iri.dup)
+      opts = resource_request_headers(iri)
+      Rack::MockRequest.env_for(path, opts)
+    end
+
+    def resource_request_headers(iri)
+      fullpath = iri.query.blank? ? iri.path : "#{iri.path}?#{iri.query}"
+
+      request.env.slice(*REQUEST_HEADERS).merge(
+        'HTTP_ACCEPT' => 'application/hex+x-ndjson',
+        'HTTP_OPERATOR_ARG_GRAPH' => 'true',
+        'ORIGINAL_FULLPATH' => fullpath
+      )
+    end
+
+    def resource_response(iri, **opts)
+      {
+        body: nil,
+        cache: :private,
+        iri: iri,
+        status: 404
+      }.merge(opts)
+    end
+
+    def response_for_wrong_host(opts)
+      iri = opts[:iri]
+      term = term_from_vocab(iri)
+      return resource_response(iri) unless term
+
+      ontology_term_response(iri, term, opts[:include])
+    end
+
+    def term_from_vocab(iri)
+      vocab = Vocab.for(iri)
+      tag = iri.split(vocab.to_s).last
+      vocab[tag]
+    rescue NoMethodError
+      nil
+    end
+
+    def ontology_term_response(iri, term, include)
+      resource_response(
+        iri,
+        body: include ? resource_body(LinkedRails.ontology_property_class.new(iri: term)) : nil,
+        cache: :public,
+        language: I18n.locale,
+        status: 200
+      )
+    end
+
+    def response_from_request(include, iri) # rubocop:disable Metrics/AbcSize
+      status, headers, rack_body = Rails.application.routes.router.serve(resource_request(iri))
+      cache_from_header = headers['Cache-Control']&.squish&.presence
+
+      resource_response(
+        iri.to_s,
+        body: include ? resource_response_body(iri, rack_body, status) : nil,
+        cache: %w[no-cache private public].include?(cache_from_header.to_s.downcase) ? cache_from_header : :private,
+        language: response_language(headers),
+        status: status
+      )
+    end
+
+    def response_language(headers)
+      headers['Content-Language'] || I18n.locale
+    end
+
+    def sanitized_relative_path(iri) # rubocop:disable Metrics/AbcSize
+      iri.path = "#{iri.path}/" unless iri.path&.ends_with?('/')
+      uri = URI(LinkedRails.iri.path.present? ? iri.to_s.split("#{LinkedRails.iri.path}/").last : iri)
+
+      [uri.path, uri.query].compact.join('?')
+    end
+
+    def timings
+      @timings ||= []
+    end
+
+    def timed_authorized_resource(resource)
+      res = nil
+      time = Benchmark.measure { res = authorized_resource(resource) }
+      unless Rails.env.production?
+        include = resource[:include].to_s.ljust(5)
+        timings << "#{time.to_s[0..-2]} - #{include}  #{res[:status]}   #{res[:cache]} #{resource[:iri]}"
+      end
+      res
+    end
+
+    def wrong_host?(iri)
+      !iri.starts_with?(LinkedRails.iri)
+    end
+  end
+end

data/app/controllers/linked_rails/current_user_controller.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module LinkedRails
+  class CurrentUserController < LinkedRails.controller_parent_class
+    active_response :show
+
+    private
+
+    def current_resource
+      @current_resource ||= LinkedRails.current_user_class.new(user: current_user)
+    end
+  end
+end

data/app/controllers/linked_rails/enum_values_controller.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module LinkedRails
+  class EnumValuesController < LinkedRails.controller_parent_class
+    active_response :index
+
+    private
+
+    def enum_options!
+      serializer_class!.enum_options(params[:attribute]) || raise(ActiveRecord::RecordNotFound)
+    end
+
+    def requested_resource
+      return super unless action_name == 'index'
+
+      @requested_resource ||= LinkedRails::Sequence.new(
+        enum_options!.values,
+        id: index_iri,
+        scope: LinkedRails::EnumValuePolicy::Scope
+      )
+    end
+
+    def model_class
+      @model_class ||= self.class.linked_models.detect do |klass|
+        klass.to_s == ([params[:module]].compact + [params[:klass]&.singularize]).join('/').classify
+      end
+    end
+
+    def model_class!
+      model_class || raise(ActiveRecord::RecordNotFound)
+    end
+
+    def serializer_class
+      @serializer_class ||= RDF::Serializers.serializer_for(model_class!)
+    end
+
+    def serializer_class!
+      serializer_class || raise(ActiveRecord::RecordNotFound)
+    end
+
+    class << self
+      def linked_models
+        @linked_models ||= ObjectSpace.each_object(Class).select do |c|
+          c.included_modules.include?(LinkedRails::Model)
+        end
+      end
+    end
+  end
+end

data/app/controllers/linked_rails/forms_controller.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module LinkedRails
+  class FormsController < LinkedRails.controller_parent_class
+    active_response :show
+
+    class << self
+      def controller_class
+        LinkedRails.form_parent_class
+      end
+    end
+  end
+end

data/app/controllers/linked_rails/manifests_controller.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module LinkedRails
+  class ManifestsController < LinkedRails.controller_parent_class
+    def show
+      render json: current_resource.web_manifest
+    end
+
+    def tenant
+      render json: {
+        iri_prefix: LinkedRails.iri.host
+      }
+    end
+
+    private
+
+    def current_resource
+      @current_resource ||= LinkedRails.manifest_class.new
+    end
+  end
+end

data/app/controllers/linked_rails/menus/items_controller.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module LinkedRails
+  module Menus
+    class ItemsController < LinkedRails.controller_parent_class
+      active_response :index
+    end
+  end
+end

data/app/controllers/linked_rails/menus/lists_controller.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module LinkedRails
+  module Menus
+    class ListsController < LinkedRails.controller_parent_class
+      active_response :show, :index
+    end
+  end
+end

data/app/controllers/linked_rails/not_found_controller.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module LinkedRails
+  class NotFoundController < LinkedRails.controller_parent_class
+    def show
+      handle_error(ActionController::RoutingError.new('Route not found'))
+    rescue ActionController::UnknownFormat
+      head 404
+    end
+
+    private
+
+    def authorize_action; end
+  end
+end