linked_rails 0.0.1

data/app/controllers/linked_rails/ontologies_controller.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module LinkedRails
+  class OntologiesController < LinkedRails.controller_parent_class
+    active_response :show
+  end
+end

data/app/models/linked_rails/actions/default_actions/create.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module LinkedRails
+  module Actions
+    module DefaultActions
+      module Create
+        def has_collection_create_action(overwrite = {}) # rubocop:disable Naming/PredicateName
+          has_collection_action(:create, create_collection_options(overwrite))
+        end
+
+        def has_singular_create_action(overwrite = {}) # rubocop:disable Naming/PredicateName
+          has_singular_action(:create, create_singular_options(overwrite))
+        end
+
+        private
+
+        def create_collection_options(overwrite = {})
+          default_create_options(
+            form: -> { resource.association_class.try(:form_class) },
+            object: -> { resource.build_child },
+            policy: :create_child?
+          ).merge(overwrite)
+        end
+
+        def create_singular_options(overwrite = {})
+          default_create_options(
+            form: -> { resource.class.try(:form_class) },
+            object: -> { resource },
+            policy: :create?,
+            url: -> { resource.singular_iri }
+          ).merge(overwrite)
+        end
+
+        def default_create_options(overwrite = {}) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+          {
+            http_method: :post,
+            image: 'fa-plus',
+            label: lambda do
+              item = LinkedRails::Actions::Item.new(resource: result_class.new, tag: :create)
+              LinkedRails.translate(:action, :label, item, false).presence ||
+                I18n.t("#{association}.type_new", default: "New #{result_class.name.demodulize.humanize}")
+            end,
+            root_relative_iri: lambda {
+              uri = resource.root_relative_iri.dup
+              uri.path ||= ''
+              uri.path += '/new'
+              uri.query = Rack::Utils.parse_nested_query(uri.query).except('display', 'sort').to_param.presence
+              uri.to_s
+            },
+            result: -> { result_class },
+            type: lambda {
+              [Vocab.ontola["Create::#{result_class}"], Vocab.schema.CreateAction]
+            },
+            url: -> { resource.iri }
+          }.merge(overwrite)
+        end
+      end
+    end
+  end
+end

data/app/models/linked_rails/actions/default_actions/destroy.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module LinkedRails
+  module Actions
+    module DefaultActions
+      module Destroy
+        def has_resource_destroy_action(overwrite = {}) # rubocop:disable Naming/PredicateName
+          has_resource_action(:destroy, destroy_resource_options(overwrite))
+        end
+
+        def has_singular_destroy_action(overwrite = {}) # rubocop:disable Naming/PredicateName
+          has_singular_action(:destroy, destroy_singular_options(overwrite))
+        end
+
+        private
+
+        def destroy_resource_options(overwrite = {})
+          default_destroy_options(overwrite)
+        end
+
+        def destroy_singular_options(overwrite = {})
+          default_destroy_options(
+            url: -> { resource.singular_iri }
+          ).merge(overwrite)
+        end
+
+        def default_destroy_options(overwrite = {}) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+          {
+            http_method: :delete,
+            image: 'fa-close',
+            policy: :destroy?,
+            root_relative_iri: lambda {
+              uri = resource.root_relative_iri.dup
+              uri.path ||= ''
+              uri.path += '/delete'
+              uri.to_s
+            },
+            type: [Vocab.schema.Action, Vocab.ontola[:DestroyAction]],
+            url: -> { resource.iri(destroy: true) }
+          }.merge(overwrite)
+        end
+      end
+    end
+  end
+end

data/app/models/linked_rails/actions/default_actions/update.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module LinkedRails
+  module Actions
+    module DefaultActions
+      module Update
+        def has_resource_update_action(overwrite = {}) # rubocop:disable Naming/PredicateName
+          has_resource_action(:update, update_resource_options(overwrite))
+        end
+
+        def has_singular_update_action(overwrite = {}) # rubocop:disable Naming/PredicateName
+          has_singular_action(:update, update_singular_options(overwrite))
+        end
+
+        private
+
+        def update_resource_options(overwrite = {})
+          default_update_options(overwrite)
+        end
+
+        def update_singular_options(overwrite = {})
+          default_update_options(
+            url: -> { resource.singular_iri }
+          ).merge(overwrite)
+        end
+
+        def default_update_options(overwrite = {}) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+          {
+            form: -> { resource.class.try(:form_class) },
+            http_method: :put,
+            image: 'fa-pencil-square-o',
+            label: lambda {
+              type = I18n.t("#{resource.class.name.tableize}.type", default: nil)
+              type.present? ? I18n.t('edit_type', type: type) : I18n.t('update')
+            },
+            policy: :update?,
+            root_relative_iri: lambda {
+              uri = resource.root_relative_iri.dup
+              uri.path ||= ''
+              uri.path += '/edit'
+              uri.to_s
+            },
+            type: Vocab.schema.UpdateAction,
+            url: -> { resource.iri }
+          }.merge(overwrite)
+        end
+      end
+    end
+  end
+end

data/app/models/linked_rails/actions/default_actions.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require_relative 'default_actions/create'
+
+module LinkedRails
+  module Actions
+    module DefaultActions
+      extend ActiveSupport::Concern
+
+      included do
+        extend LinkedRails::Actions::DefaultActions::Create
+        extend LinkedRails::Actions::DefaultActions::Destroy
+        extend LinkedRails::Actions::DefaultActions::Update
+      end
+    end
+  end
+end

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

@@ -0,0 +1,234 @@
+# frozen_string_literal: true
+
+require 'pundit'
+
+module LinkedRails
+  module Actions
+    class Item # rubocop:disable Metrics/ClassLength
+      include ActiveModel::Model
+      include LinkedRails::Model
+      enhance LinkedRails::Enhancements::Singularable
+
+      attr_accessor :list, :policy_arguments, :submit_label
+      attr_writer :parent, :resource, :root_relative_iri, :user_context, :object,
+                  :target
+      delegate :user_context, to: :list, allow_nil: true
+
+      %i[description result type policy label image url include_object include_paths collection condition form completed
+         tag http_method favorite path policy_resource predicate resource].each do |method|
+        attr_writer method
+        define_method method do
+          var = instance_variable_get(:"@#{method}")
+          value = var.respond_to?(:call) ? list.instance_exec(&var) : var
+          return instance_variable_set(:"@#{method}", value).presence if value
+
+          send("#{method}_fallback") if respond_to?("#{method}_fallback", true)
+        end
+      end
+
+      def action_status
+        @action_status ||=
+          if completed
+            Vocab.schema.CompletedActionStatus
+          elsif policy_valid?
+            Vocab.schema.PotentialActionStatus
+          elsif policy_expired?
+            Vocab.ontola[:ExpiredActionStatus]
+          else
+            Vocab.ontola[:DisabledActionStatus]
+          end
+      end
+
+      def as_json(_opts = {})
+        {}
+      end
+
+      def available?
+        return false unless action_status == Vocab.schema.PotentialActionStatus
+
+        @condition.nil? || condition
+      end
+
+      def built_associations
+        included_object
+          .class
+          .try(:reflect_on_all_associations)
+          &.select { |association| included_object.association(association.name).loaded? }
+          &.map(&:name)
+      end
+
+      def error
+        policy_message ||
+          I18n.t("actions.status.#{action_status.to_s.split('#').last}", default: nil)
+      end
+
+      def form_resource_includes # rubocop:disable Metrics/CyclomaticComplexity
+        return {} if included_object.nil?
+        return include_paths || {} if iri.anonymous?
+
+        includes = included_object.class.try(:preview_includes)&.presence || []
+
+        (includes.is_a?(Hash) ? [includes] : includes) + (built_associations || [])
+      end
+
+      def included_object
+        object if include_object || object&.iri&.anonymous?
+      end
+
+      def object
+        @object = list.instance_exec(&@object) if @object.respond_to?(:call)
+
+        @object || resource
+      end
+
+      def parent
+        return @parent if instance_variable_defined?(:@parent)
+
+        if resource.is_a?(LinkedRails.collection_class)
+          resource.parent
+        else
+          resource
+        end
+      end
+
+      def policy_message
+        resource_policy.try(:message) if action_status == Vocab.ontola[:DisabledActionStatus]
+      end
+
+      def root_relative_iri(_opts = {})
+        value = root_relative_iri_from_var
+        value = RDF::URI(value) unless value.blank? || value.is_a?(RDF::URI)
+        return @root_relative_iri = value if value
+
+        super
+      end
+
+      def root_relative_singular_iri
+        value = root_relative_iri.to_s.sub(resource.root_relative_iri, resource.root_relative_singular_iri)
+
+        RDF::URI(value)
+      end
+
+      def preview_includes
+        [:target, included_object: form_resource_includes]
+      end
+
+      def singular_resource?
+        resource.try(:singular_resource?)
+      end
+
+      def iri_opts
+        resource&.iri_opts || {}
+      end
+
+      def iri_template
+        path_suffix = path.blank? ? "/actions/#{tag}" : "/#{path}"
+
+        return @iri_template ||= URITemplate.new(path_suffix) if resource.blank?
+
+        @iri_template ||= iri_template_expand_path(resource.send(:iri_template), path_suffix)
+      end
+
+      def rdf_type
+        type
+      end
+
+      def target
+        @target ||= LinkedRails.entry_point_class.new(parent: self)
+      end
+
+      def user_context
+        @user_context || list.user_context
+      end
+
+      private
+
+      def description_fallback
+        LinkedRails.translate(:action, :description, self, false)
+      end
+
+      def label_fallback
+        LinkedRails.translate(:action, :label, self)
+      end
+
+      def policy_expired?
+        @policy_expired ||= policy && resource_policy.try(:expired?)
+      end
+
+      def policy_resource_fallback
+        resource
+      end
+
+      def policy_valid?
+        return true if policy.blank?
+        return false if policy_resource.blank?
+
+        @policy_valid ||= resource_policy.send(policy, *policy_arguments)
+      end
+
+      def predicate_fallback
+        Vocab.ontola["#{tag}_action".camelize(:lower)]
+      end
+
+      def resource_fallback
+        list&.resource
+      end
+
+      def resource_policy
+        @resource_policy ||= Pundit.policy!(user_context, policy_resource) if policy_resource
+      end
+
+      def root_relative_iri_from_var
+        return list.instance_exec(&@root_relative_iri) if @root_relative_iri.respond_to?(:call)
+
+        @root_relative_iri
+      end
+
+      def type_fallback
+        Vocab.schema.UpdateAction
+      end
+
+      class << self
+        def app_action_list_class
+          return @app_action_list_class if instance_variables.include?(:@app_action_list_class)
+
+          @app_action_list_class = 'AppActionList'.safe_constantize
+        end
+
+        def app_action_list(user_context)
+          app_action_list_class&.new(
+            resource: nil,
+            user_context: user_context
+          )
+        end
+
+        def requested_index_resource(params, user_context)
+          parent = parent_from_params(params, user_context)
+          action_list = parent ? parent.action_list(user_context) : app_action_list(user_context)
+
+          LinkedRails.collection_class.new(
+            association_base: action_list.actions,
+            association_class: ::Actions::Item,
+            default_display: :grid,
+            default_title: I18n.t('actions.plural'),
+            parent: parent,
+            title: params[:title]
+          )
+        end
+
+        def requested_single_resource(params, user_context)
+          return nil if params[:id].blank?
+
+          parent = parent_from_params(params, user_context)
+          action_list = parent ? parent.action_list(user_context) : app_action_list(user_context)
+
+          action_list&.action(params[:id].to_sym)
+        end
+
+        def route_key
+          :actions
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+require_relative 'item'
+
+module LinkedRails
+  module Actions
+    class List
+      include ActiveModel::Model
+      include LinkedRails::Model
+      include DefaultActions
+      extend LinkedRails::Enhanceable
+
+      attr_accessor :resource, :user_context
+      class_attribute :_defined_actions, instance_reader: false, instance_writer: false
+
+      def actions
+        @actions ||= defined_actions.map { |tag, opts| action_item(tag, opts.dup) }
+      end
+
+      def action(tag)
+        action_item(tag, defined_actions[tag].dup) if defined_actions.key?(tag)
+      end
+
+      def defined_actions
+        if resource.is_a?(LinkedRails.collection_class)
+          self.class.collection_actions
+        elsif resource.try(:singular_resource?)
+          self.class.singular_actions
+        else
+          self.class.resource_actions
+        end
+      end
+
+      private
+
+      def action_item(tag, options)
+        options[:tag] ||= options[:action_tag] || tag
+        options[:list] ||= self
+        LinkedRails.actions_item_class.new(options.except(:action_tag))
+      end
+
+      def association
+        @association ||= result_class.to_s.demodulize.tableize
+      end
+
+      def call_option(option, _resource)
+        option.respond_to?(:call) ? instance_exec(&option) : option
+      end
+
+      def result_class
+        @result_class ||= self.class.actionable_class
+      end
+
+      class << self
+        def actionable_class
+          @actionable_class ||=
+            name.gsub('ActionList', '').safe_constantize ||
+            name.demodulize.gsub('ActionList', '').safe_constantize
+        end
+
+        def collection_actions
+          defined_actions[:collection]
+        end
+
+        def defined_actions
+          initialize_actions
+          _defined_actions || initial_defined_actions
+        end
+
+        def resource_actions
+          defined_actions[:resource]
+        end
+
+        def singular_actions
+          defined_actions[:singular]
+        end
+
+        private
+
+        def has_collection_action(action, opts = {}) # rubocop:disable Naming/PredicateName
+          opts[:http_method] ||= 'POST'
+          defined_actions[:collection][action] = opts
+        end
+
+        def has_resource_action(action, opts = {}) # rubocop:disable Naming/PredicateName
+          opts[:http_method] ||= 'POST'
+          defined_actions[:resource][action] = opts
+        end
+
+        def has_singular_action(action, opts = {}) # rubocop:disable Naming/PredicateName
+          opts[:http_method] ||= 'POST'
+          defined_actions[:singular][action] = opts
+        end
+
+        def initial_defined_actions(clone_from = {})
+          {
+            collection: clone_from[:collection].dup || {},
+            resource: clone_from[:resource].dup || {},
+            singular: clone_from[:singular].dup || {}
+          }
+        end
+
+        def initialize_actions
+          return if _defined_actions && method(:_defined_actions).owner == singleton_class
+
+          self._defined_actions = initial_defined_actions(superclass.try(:_defined_actions) || {})
+        end
+      end
+
+      enhanceable :actionable_class, :Action
+    end
+  end
+end