linked_rails 0.0.1

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

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module LinkedRails
+  module Enhancements
+    module Indexable
+      module Model
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module LinkedRails
+  module Enhancements
+    module Menuable
+      module Model
+        extend ActiveSupport::Concern
+
+        def menus(user_context = nil)
+          menu_list(user_context).menus
+        end
+
+        def menu(tag, user_context = nil)
+          menu_list(user_context).menu(tag)
+        end
+
+        def menu_list(user_context = nil)
+          @menu_list = {}
+          @menu_list[user_context] ||= self.class.menu_class.new(resource: self, user_context: user_context)
+        end
+
+        module ClassMethods
+          def menu_class
+            @menu_class ||= "#{name}MenuList".safe_constantize || "#{superclass.name}MenuList".safe_constantize
+          end
+
+          def preview_includes
+            return super if menu_class.blank?
+
+            super + menu_class.defined_menus.keys.map { |tag| "#{tag}_menu" }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module LinkedRails
+  module Enhancements
+    module Menuable
+      module Serializer
+        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
+end

data/lib/linked_rails/enhancements/route_concerns.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module LinkedRails
+  module Enhancements
+    class RouteConcerns
+      cattr_accessor :enhancement_concerns, default: []
+
+      class << self
+        def add_concern(opts)
+          enhancement_concerns << opts unless enhancement_concerns.include?(opts)
+        end
+      end
+    end
+  end
+end
+
+module ActionDispatch
+  module Routing
+    class Mapper
+      def include_route_concerns(klass: @scope[:controller].classify.constantize, only: nil, except: [])
+        include =
+          if klass.respond_to?(:each)
+            klass.map(&method(:route_concerns_for)).flatten.uniq
+          else
+            route_concerns_for(klass)
+          end
+
+        include &= only unless only.nil?
+        include -= except
+
+        concerns include
+      end
+
+      def add_missing_concern(enhancement)
+        return if @concerns.include?(concern_key_from_enhancement(enhancement))
+
+        module_parent_for(enhancement).route_concerns(self)
+      end
+
+      def concern_key_from_enhancement(enhancement)
+        module_parent_for(enhancement).to_s.demodulize.underscore.to_sym
+      end
+
+      def route_concerns_for(klass)
+        klass
+          .enhancement_modules(:Routing)
+          .each(&method(:add_missing_concern))
+          .map(&method(:concern_key_from_enhancement))
+      end
+
+      def module_parent_for(klass)
+        Rails.version < '6' ? klass.parent : klass.module_parent
+      end
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module LinkedRails
+  module Enhancements
+    module Singularable
+      module Controller
+        extend ActiveSupport::Concern
+
+        private
+
+        def create_meta
+          data = super
+          data << same_as_statement
+          data
+        end
+
+        def destroy_meta
+          data = super
+          data << remove_same_as_delta
+          data
+        end
+
+        def same_as_statement
+          return [] unless current_resource.respond_to?(:singular_iri)
+
+          [
+            current_resource.singular_iri,
+            Vocab.owl.sameAs,
+            current_resource.iri
+          ]
+        end
+
+        def singular_route?
+          params[:singular_route]
+        end
+
+        def remove_same_as_delta
+          invalidate_resource_delta(current_resource.singular_iri)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module LinkedRails
+  module Enhancements
+    module Singularable
+      module Model
+        extend ActiveSupport::Concern
+
+        included do
+          attr_accessor :singular_resource
+
+          alias_method :singular_resource?, :singular_resource
+        end
+
+        def root_relative_singular_iri(opts = {})
+          RDF::URI(self.class.singular_iri_template.expand(singular_iri_opts.merge(opts)))
+        end
+
+        def root_relative_iri(opts = {})
+          return super unless anonymous_iri?
+
+          root_relative_singular_iri(opts)
+        end
+
+        def singular_iri(opts = {})
+          return iri_with_root(root_relative_singular_iri(opts)) if opts.present?
+
+          @singular_iri ||= iri_with_root(root_relative_singular_iri)
+        end
+
+        class_methods do
+          def requested_singular_resource(_params, _user_context)
+            raise(NotImplementedError)
+          end
+
+          def singular_iri_template
+            @singular_iri_template ||= URITemplate.new("{/parent_iri*}/#{singular_route_key}{#fragment}")
+          end
+
+          def singular_route_key
+            name.underscore
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module LinkedRails
+  module Enhancements
+    module Singularable
+      module Serializer
+        extend ActiveSupport::Concern
+
+        included do
+          statements :same_as_statement
+
+          def self.same_as_statement(object, _params)
+            return [] unless object.singular_resource? && object.singular_iri != object.iri
+
+            [
+              RDF::Statement.new(
+                object.singular_iri,
+                Vocab.owl.sameAs,
+                object.iri,
+                graph_name: Vocab.ll[:supplant]
+              )
+            ]
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module LinkedRails
+  module Enhancements
+    module Tableable
+      module Model
+        extend ActiveSupport::Concern
+
+        included do
+          class_attribute :defined_columns
+        end
+
+        module ClassMethods
+          def with_columns(opts)
+            initialize_columns
+            defined_columns.merge!(opts)
+          end
+
+          def initialize_columns
+            return if defined_columns && method(:defined_columns).owner == singleton_class
+
+            self.defined_columns = superclass.try(:defined_columns)&.dup || {}
+          end
+        end
+      end
+    end
+  end
+end

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

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

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

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

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

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module LinkedRails
+  module Enhancements
+    module Updatable
+      module Routing; end
+
+      class << self
+        def route_concerns(mapper)
+          mapper.concern :updatable do
+            mapper.member do
+              mapper.patch :update
+              mapper.put   :update
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module LinkedRails
+  module Enhancements
+    module Updatable
+      module Serializer
+        extend ActiveSupport::Concern
+
+        included do
+          attribute :updated_at, predicate: Vocab.schema.dateModified do |object|
+            object.try(:updated_at)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/linked_rails/enhancements.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require_relative 'enhancements/route_concerns'
+
+require_relative 'enhancements/actionable/model'
+require_relative 'enhancements/actionable/serializer'
+require_relative 'enhancements/creatable/action'
+require_relative 'enhancements/creatable/controller'
+require_relative 'enhancements/destroyable/action'
+require_relative 'enhancements/destroyable/controller'
+require_relative 'enhancements/destroyable/routing'
+require_relative 'enhancements/indexable/model'
+require_relative 'enhancements/menuable/model'
+require_relative 'enhancements/menuable/serializer'
+require_relative 'enhancements/singularable/controller'
+require_relative 'enhancements/singularable/model'
+require_relative 'enhancements/singularable/serializer'
+require_relative 'enhancements/tableable/model'
+require_relative 'enhancements/updatable/action'
+require_relative 'enhancements/updatable/controller'
+require_relative 'enhancements/updatable/routing'
+require_relative 'enhancements/updatable/serializer'

data/lib/linked_rails/helpers/delta_helper.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module LinkedRails
+  module Helpers
+    module DeltaHelper
+      def changed_relation_triples(predicate, destructed, resources)
+        related_resource_invalidations = resources.map(&method(:invalidate_resource_delta))
+
+        return related_resource_invalidations unless predicate
+
+        if destructed
+          return related_resource_invalidations + [
+            [current_resource.iri, predicate, Vocab.sp[:Variable], delta_iri(:remove)]
+          ]
+        end
+
+        related_resource_invalidations + resources.map do |resource|
+          [current_resource.iri, predicate, resource.iri, delta_iri(:replace)]
+        end
+      end
+
+      def changed_relations_triples # rubocop:disable Metrics/AbcSize
+        current_resource.previously_changed_relations.flat_map do |key, value|
+          if key.to_s.ends_with?('_collection')
+            [invalidate_collection_delta(current_resource.send(key))]
+          else
+            destructed = current_resource.send(:association_has_destructed?, key)
+            many = value.relationship_type == :has_many
+            relation = current_resource.send(key)
+            changed_relation_triples(value.predicate, destructed, many ? relation : [relation])
+          end
+        end
+      end
+
+      def change_triple(predicate, value)
+        if value.nil?
+          RDF::Statement.new(current_resource.iri, predicate, Vocab.sp[:Variable], graph_name: delta_iri(:remove))
+        else
+          RDF::Statement.new(current_resource.iri, predicate, value, graph_name: delta_iri(:replace))
+        end
+      end
+
+      def changes_triples # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+        serializer = RDF::Serializers.serializer_for(current_resource).new(current_resource)
+
+        current_resource.previous_changes_by_predicate.map do |predicate, (_old_value, _new_value)|
+          serializer_attributes = current_resource.class.predicate_mapping[predicate]
+          next if serializer_attributes.is_a?(FastJsonapi::Relationship)
+
+          attr_name = serializer_attributes.key
+          serialized_value =
+            serializer.class.attributes_to_serialize[attr_name]&.serialize(current_resource, serializer_params, {})
+          (serialized_value.is_a?(Array) ? serialized_value : [serialized_value]).map do |value|
+            change_triple(predicate, value)
+          end
+        end.compact.flatten
+      end
+
+      def delta_iri(delta)
+        %i[remove replace invalidate].include?(delta) ? Vocab.ontola[delta] : Vocab.ll[delta]
+      end
+
+      def invalidate_collection_delta(collection)
+        [Vocab.sp[:Variable], Vocab.ontola[:baseCollection], collection.iri, delta_iri(:invalidate)]
+      end
+
+      def invalidate_parent_collections_delta(resource)
+        resource&.parent_collections(try(:user_context))&.map(&method(:invalidate_collection_delta)) || []
+      end
+
+      def invalidate_resource_delta(resource)
+        iri = resource.is_a?(RDF::Resource) ? resource : resource.iri
+
+        [iri, Vocab.sp[:Variable], Vocab.sp[:Variable], delta_iri(:invalidate)]
+      end
+
+      def resource_added_delta(resource)
+        invalidate_parent_collections_delta(resource)
+      end
+
+      def resource_removed_delta(resource)
+        invalidate_parent_collections_delta(resource)
+      end
+    end
+  end
+end