linked_rails 0.0.1

data/lib/linked_rails/cache.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module LinkedRails
+  class Cache
+    extend RDF::Serializers::HextupleSerializer
+
+    class << self
+      def invalidate(iri)
+        write([invalidate_resource(iri)])
+      end
+
+      def invalidate_all
+        invalidate(Vocab.sp.Variable)
+      end
+
+      def write(delta)
+        Redis.new.publish(
+          ENV['CACHE_CHANNEL'],
+          delta.map { |s| Oj.fast_generate(value_to_hex(*s)) }.join("\n")
+        )
+      end
+
+      private
+
+      def invalidate_resource(iri)
+        [
+          Vocab.sp.Variable,
+          Vocab.sp.Variable,
+          Vocab.sp.Variable,
+          LinkedRails::Vocab.ontola["invalidate?graph=#{CGI.escape(iri)}"]
+        ]
+      end
+    end
+  end
+end

data/lib/linked_rails/callable_variable.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module LinkedRails
+  module CallableVariable
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      def callable_variable(method, opts = {}) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+        variable ||= opts[:variable] || method
+        default ||= opts[:default]
+
+        define_method method do
+          value = instance_variable_get("@#{variable}")
+          if value.respond_to?(:call)
+            instance = opts[:instance] ? send(opts[:instance]) : self
+            value = instance_variable_set("@#{variable}", instance.instance_exec(&value))
+          end
+          return value if !value.nil? || default.blank?
+
+          instance_exec(&default)
+        end
+      end
+    end
+  end
+end

data/lib/linked_rails/constraints/whitelist.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module LinkedRails
+  module Constraints
+    module Whitelist
+      module_function
+
+      def matches?(request)
+        return true unless LinkedRails.whitelisted_spi_ips
+
+        ip = request_ip(request.ip)
+        remote_ip = request_ip(request.remote_ip)
+
+        allowed = [ip, remote_ip].all? do |req_ip|
+          LinkedRails.whitelisted_spi_ips.any? { |allowed_ip| allowed_ip.include?(req_ip) }
+        end
+        log_verdict(allowed, request, ip, remote_ip)
+
+        allowed
+      end
+
+      def log_verdict(allowed, request, ip, remote_ip)
+        return if Rails.env.production?
+
+        verdict = allowed ? 'pass' : 'fail'
+        Rails.logger.debug("[WhitelistConstraint] #{verdict} for #{request.url} by ip: #{ip}, remote ip: #{remote_ip}")
+      end
+
+      def request_ip(ip)
+        return nil unless ip.is_a?(String) && ip.present?
+
+        IPAddr.new(ip)
+      end
+    end
+  end
+end

data/lib/linked_rails/controller/authorization.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module LinkedRails
+  module Controller
+    module Authorization
+      extend ActiveSupport::Concern
+
+      def authorize_action
+        query = action_name == 'index' ? :show? : "#{params[:action].chomp('!')}?"
+
+        authorize(current_resource!, query)
+      end
+    end
+  end
+end

data/lib/linked_rails/controller/error_handling.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module LinkedRails
+  module Controller
+    module ErrorHandling
+      extend ActiveSupport::Concern
+      included do
+        rescue_from StandardError, with: :handle_and_report_error
+        rescue_from ActiveRecord::RecordNotFound, with: :handle_error
+        rescue_from Pundit::NotAuthorizedError, with: :handle_error
+      end
+
+      private
+
+      def add_error_snackbar(error)
+        add_exec_action_header(response.headers, ontola_snackbar_action(error.error.message))
+      end
+
+      def add_error_snackbar?(_error)
+        !%w[GET HEAD].include?(request.method)
+      end
+
+      def handle_error(error)
+        respond_to do |format|
+          (LinkedRails::Renderers.rdf_content_types + [:json]).each do |type|
+            format.send(type) { error_response_serializer(error, type) }
+          end
+        end
+      end
+
+      def handle_and_report_error(error)
+        raise if Rails.env.development? || Rails.env.test?
+        raise if response_body
+
+        handle_error(error)
+      end
+
+      def error_mode(exception)
+        @_error_mode = true
+        Rails.logger.error exception
+        @_uc = nil
+      end
+
+      def error_resource(status, error, url = request.original_url)
+        LinkedRails.rdf_error_class.new(status, url, error)
+      end
+
+      def error_response_serializer(error, type, status: nil)
+        status ||= error_status(error)
+        error = error_resource(status, error)
+        add_error_snackbar(error) if add_error_snackbar?(error)
+        render type => error, status: status
+      end
+
+      def error_status(error)
+        self.class.error_status_codes[error.class.to_s] || 500
+      end
+
+      module ClassMethods
+        def error_status_codes # rubocop:disable Metrics/MethodLength
+          @error_status_codes ||= {
+            'ActionController::ParameterMissing' => 422,
+            'ActionController::RoutingError' => 404,
+            'ActionController::UnpermittedParameters' => 422,
+            'ActiveRecord::RecordNotFound' => 404,
+            'ActiveRecord::RecordNotUnique' => 304,
+            'Doorkeeper::Errors::InvalidGrantReuse' => 422,
+            'LinkedRails::Auth::Errors::Expired' => 410,
+            'LinkedRails::Auth::Errors::Unauthorized' => 401,
+            'Pundit::NotAuthorizedError' => 403
+          }
+        end
+      end
+    end
+  end
+end

data/lib/linked_rails/controller.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require_relative 'active_response/controller'
+require_relative 'controller/authorization'
+require_relative 'controller/error_handling'
+
+module LinkedRails
+  module Controller
+    extend ActiveSupport::Concern
+
+    included do
+      extend Enhanceable
+
+      enhanceable :controller_class, :Controller
+
+      include LinkedRails::ActiveResponse::Controller
+      include LinkedRails::Controller::Authorization
+      include LinkedRails::Controller::ErrorHandling
+      include LinkedRails::Helpers::OntolaActionsHelper
+      include LinkedRails::Helpers::DeltaHelper
+      include LinkedRails::Helpers::ResourceHelper
+
+      before_action :set_manifest_header
+    end
+
+    private
+
+    def controller_class
+      self.class.controller_class
+    end
+
+    def set_manifest_header
+      response.headers['Manifest'] = LinkedRails.iri(path: '/manifest.json')
+    end
+
+    module ClassMethods
+      def controller_class
+        @controller_class ||=
+          name.sub(/Controller$/, '').classify.safe_constantize || controller_name.classify.safe_constantize
+      end
+    end
+  end
+end

data/lib/linked_rails/engine.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module LinkedRails
+  class Engine < ::Rails::Engine
+    isolate_namespace LinkedRails
+  end
+end

data/lib/linked_rails/enhanceable.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module LinkedRails
+  module Enhanceable
+    def include_enhancements(klass_method, enhanceable)
+      send(klass_method)
+        .try(:enhancement_modules, enhanceable)
+        &.reject { |mod| include? mod }
+        &.each { |mod| include mod }
+    end
+
+    def enhanceable(klass_method, enhanceable)
+      include_enhancements(klass_method, enhanceable)
+
+      define_singleton_method('inherited') do |target|
+        super(target)
+        target.include_enhancements(klass_method, enhanceable) if target.name
+      end
+    end
+  end
+end

data/lib/linked_rails/enhancements/actionable/model.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module LinkedRails
+  module Enhancements
+    module Actionable
+      module Model
+        extend ActiveSupport::Concern
+
+        def actions(user_context = nil)
+          action_list(user_context).actions
+        end
+
+        def action(tag, user_context = nil)
+          actions(user_context).find { |a| a.tag == tag }
+        end
+
+        def action_list(user_context)
+          @action_list ||= {}
+          @action_list[user_context] ||= self.class.action_list.new(resource: self, user_context: user_context)
+        end
+
+        def action_triples
+          @action_triples ||= triples_for_actions(actions) + triples_for_actions(collection_actions)
+        end
+
+        def collection_actions
+          (try(:collections) || []).map do |opts|
+            collection_for(opts[:name]).actions
+          end.flatten
+        end
+
+        private
+
+        def triples_for_actions(actions)
+          actions.flat_map do |action|
+            triples = [
+              [iri, action.predicate, action.iri],
+              [iri, Vocab.schema.potentialAction, action.iri]
+            ]
+            triples << [iri, LinkedRails::Vocab.ontola[:favoriteAction], action.iri] if action.favorite
+            triples
+          end
+        end
+
+        module ClassMethods
+          def action_list
+            return @action_list if @action_list.try(:actionable_class) == self
+
+            @action_list = defined_action_list || define_action_list
+          end
+
+          private
+
+          def action_superclass
+            superclass.try(:action_list) || LinkedRails.action_list_parent_class
+          end
+
+          def defined_action_list
+            "#{name}ActionList".safe_constantize
+          end
+
+          def define_action_list
+            list = const_set("#{name.demodulize}ActionList", Class.new(action_superclass))
+            list.include_enhancements(:actionable_class, :Action)
+            list
+          end
+        end
+      end
+    end
+  end
+end

data/lib/linked_rails/enhancements/actionable/serializer.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module LinkedRails
+  module Enhancements
+    module Actionable
+      module Serializer
+        extend ActiveSupport::Concern
+
+        included do
+          statements :action_triples
+        end
+
+        class_methods do
+          def action_triples(object, _params)
+            if object.iri.anonymous? && !object.singular_resource?
+              []
+            else
+              object.action_triples
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/linked_rails/enhancements/creatable/action.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module LinkedRails
+  module Enhancements
+    module Creatable
+      module Action
+        extend ActiveSupport::Concern
+
+        included do
+          has_collection_create_action
+        end
+      end
+    end
+  end
+end

data/lib/linked_rails/enhancements/creatable/controller.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module LinkedRails
+  module Enhancements
+    module Creatable
+      module Controller
+        extend ActiveSupport::Concern
+
+        included do
+          active_response :create
+        end
+      end
+    end
+  end
+end

data/lib/linked_rails/enhancements/destroyable/action.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module LinkedRails
+  module Enhancements
+    module Destroyable
+      module Action
+        extend ActiveSupport::Concern
+
+        included do
+          has_resource_destroy_action
+        end
+      end
+    end
+  end
+end

data/lib/linked_rails/enhancements/destroyable/controller.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module LinkedRails
+  module Enhancements
+    module Destroyable
+      module Controller
+        extend ActiveSupport::Concern
+
+        included do
+          active_response :destroy
+        end
+      end
+    end
+  end
+end

data/lib/linked_rails/enhancements/destroyable/routing.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module LinkedRails
+  module Enhancements
+    module Destroyable
+      module Routing; end
+
+      class << self
+        def route_concerns(mapper)
+          mapper.concern :destroyable do
+            mapper.member do
+              mapper.delete '', action: :destroy
+            end
+          end
+        end
+      end
+    end
+  end
+end