plutonium 0.5.0

data/lib/plutonium/core/autodiscovery/input_discoverer.rb

@@ -0,0 +1,33 @@
+module Plutonium
+  module Core
+    module Autodiscovery
+      module InputDiscoverer
+        extend ActiveSupport::Concern
+        include Discoverer
+
+        class_methods do
+          private
+
+          def autodiscovery_input_cache = @autodiscovery_input_cache ||= {}
+        end
+
+        private
+
+        # If cache_discovery is enabled, use the class level cache that persists
+        # between requests, otherwise use the instance one.
+        def autodiscovery_input_cache
+          if Plutonium::Config.cache_discovery
+            self.class.autodiscovery_input_cache
+          else
+            @autodiscovery_input_cache ||= {}
+          end
+        end
+
+        def autodiscover_input(name)
+          autodiscovery_input_cache[name] ||=
+            Plutonium::Core::Fields::Inputs::Factory.for_resource_attribute(resource_class, name)
+        end
+      end
+    end
+  end
+end

data/lib/plutonium/core/autodiscovery/renderer_discoverer.rb

@@ -0,0 +1,33 @@
+module Plutonium
+  module Core
+    module Autodiscovery
+      module RendererDiscoverer
+        extend ActiveSupport::Concern
+        include Discoverer
+
+        class_methods do
+          private
+
+          def autodiscovery_renderer_cache = @autodiscovery_renderer_cache ||= {}
+        end
+
+        private
+
+        # If cache_discovery is enabled, use the class level cache that persists
+        # between requests, otherwise use the instance one.
+        def autodiscovery_renderer_cache
+          if Plutonium::Config.cache_discovery
+            self.class.autodiscovery_renderer_cache
+          else
+            @autodiscovery_renderer_cache ||= {}
+          end
+        end
+
+        def autodiscover_renderer(name)
+          autodiscovery_renderer_cache[name] ||=
+            Plutonium::Core::Fields::Renderers::Factory.for_resource_attribute(resource_class, name)
+        end
+      end
+    end
+  end
+end

data/lib/plutonium/core/autodiscovery.rb

@@ -0,0 +1,13 @@
+module Plutonium
+  module Core
+    module Autodiscovery
+      extend ActiveSupport::Autoload
+
+      eager_autoload do
+        autoload :Discoverer
+        autoload :InputDiscoverer
+        autoload :RendererDiscoverer
+      end
+    end
+  end
+end

data/lib/plutonium/core/controllers/authorizable.rb

@@ -0,0 +1,56 @@
+require "pundit"
+
+module Plutonium
+  module Core
+    module Controllers
+      module Authorizable
+        extend ActiveSupport::Concern
+        include Pundit::Authorization
+
+        included do
+          after_action :verify_authorized
+          after_action :verify_policy_scoped, except: %i[new create]
+
+          helper_method :permitted_attributes
+        end
+
+        private
+
+        def policy_namespace(scope)
+          raise NotImplementedError, "policy_namespace"
+        end
+
+        def pundit_user
+          resource_context
+        end
+
+        def policy(scope)
+          super(policy_namespace(scope))
+        end
+
+        def policy_scope(scope)
+          super(policy_namespace(scope))
+        end
+
+        def authorize(record, query = nil)
+          super(policy_namespace(record), query)
+        end
+
+        def permitted_attributes
+          @permitted_attributes ||= current_policy.send :"permitted_attributes_for_#{action_name}"
+        end
+
+        def current_policy
+          @current_policy ||= begin
+            policy_subject = resource_record || resource_class
+            policy(policy_subject)
+          end
+        end
+
+        def parent_policy
+          @parent_policy ||= policy(current_parent) if current_parent.present?
+        end
+      end
+    end
+  end
+end

data/lib/plutonium/core/controllers/bootable.rb

@@ -0,0 +1,44 @@
+module Plutonium
+  module Core
+    module Controllers
+      module Bootable
+        extend ActiveSupport::Concern
+
+        included do
+          class_attribute :package
+          class_attribute :resource_class, instance_writer: false, instance_predicate: false
+
+          helper_method :resource_class
+        end
+
+        class_methods do
+          def current_engine
+            "#{package}::Engine".constantize
+          end
+
+          private
+
+          def boot(package)
+            self.package = package
+
+            prepend_view_path current_engine.paths["app/views"].first
+          end
+
+          def controller_for(resource_class)
+            self.resource_class = resource_class
+          end
+        end
+
+        private
+
+        def current_engine
+          @current_engine ||= self.class.current_engine
+        end
+
+        def current_package
+          self.class.package
+        end
+      end
+    end
+  end
+end

data/lib/plutonium/core/controllers/crud_actions.rb

@@ -0,0 +1,128 @@
+module Plutonium
+  module Core
+    module Controllers
+      module CrudActions
+        extend ActiveSupport::Concern
+
+        # GET /resources(.{format})
+        def index
+          authorize resource_class
+
+          @ransack = policy_scope(resource_class).ransack(params[:q])
+          @pagy, @resource_records = pagy @ransack.result
+          @collection = build_collection
+
+          render :index
+        end
+
+        # GET /resources/1(.{format})
+        def show
+          authorize resource_record
+
+          @detail = build_detail
+
+          render :show
+        end
+
+        # GET /resources/new
+        def new
+          authorize resource_class
+
+          @resource_record = resource_class.new
+          # set params if they have been passed
+          resource_record.attributes = params[resource_param_key].present? ? resource_params : {}
+          @form = build_form
+
+          render :new
+        end
+
+        # GET /resources/1/edit
+        def edit
+          authorize resource_record
+
+          # set params if they have been passed
+          resource_record.attributes = params[resource_param_key].present? ? resource_params : {}
+          @form = build_form
+
+          render :edit
+        end
+
+        # POST /resources(.{format})
+        def create
+          authorize resource_class
+
+          @resource_record = resource_class.new resource_params
+
+          respond_to do |format|
+            if resource_record.save
+              format.html do
+                redirect_to adapt_route_args(resource_record),
+                  notice: "#{resource_class.model_name.human} was successfully created."
+              end
+              format.any { render :show, status: :created, location: adapt_route_args(resource_record) }
+            else
+              format.html do
+                @form = build_form
+                render :new, status: :unprocessable_entity
+              end
+              format.any do
+                @errors = resource_record.errors
+                render "errors", status: :unprocessable_entity
+              end
+            end
+          end
+        end
+
+        # PATCH/PUT /resources/1(.{format})
+        def update
+          authorize resource_record
+
+          respond_to do |format|
+            if resource_record.update(resource_params)
+              format.html do
+                redirect_to adapt_route_args(resource_record), notice: "#{resource_class.model_name.human} was successfully updated.",
+                  status: :see_other
+              end
+              format.any { render :show, status: :ok, location: adapt_route_args(resource_record) }
+            else
+              format.html do
+                @form = build_form
+                render :edit, status: :unprocessable_entity
+              end
+              format.any do
+                @errors = resource_record.errors
+                render "errors", status: :unprocessable_entity
+              end
+            end
+          end
+        end
+
+        # DELETE /resources/1(.{format})
+        def destroy
+          authorize resource_record
+
+          respond_to do |format|
+            resource_record.destroy
+
+            format.html do
+              redirect_to adapt_route_args(resource_class),
+                notice: "#{resource_class.model_name.human} was successfully deleted."
+            end
+            format.json { head :no_content }
+          rescue ActiveRecord::InvalidForeignKey
+            format.html do
+              redirect_to adapt_route_args(resource_record),
+                alert: "#{resource_class.model_name.human} is referenced by other records."
+            end
+            format.any do
+              @errors = ActiveModel::Errors.new resource_record
+              @errors.add :base, :existing_references, message: "is referenced by other records"
+
+              render "errors", status: :unprocessable_entity
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/plutonium/core/controllers/entity_scoping.rb

@@ -0,0 +1,69 @@
+module Plutonium
+  module Core
+    module Controllers
+      module EntityScoping
+        extend ActiveSupport::Concern
+
+        included do
+          before_action :remember_scoped_entity
+          helper_method :current_scoped_entity
+        end
+
+        private
+
+        def scoped_to_entity?
+          current_engine.scoped_to_entity?
+        end
+
+        def scoped_entity_class
+          ensure_legal_entity_scoping_method_access! :scoped_entity_class
+
+          current_engine.scoped_entity_class
+        end
+
+        def scoped_entity_param_key
+          ensure_legal_entity_scoping_method_access! :scoped_entity_param_key
+
+          current_engine.scoped_entity_param_key
+        end
+
+        def scoped_entity_session_key
+          ensure_legal_entity_scoping_method_access! :scoped_entity_session_key
+
+          :scoped_entity_id
+        end
+
+        def current_scoped_entity
+          ensure_legal_entity_scoping_method_access! :current_scoped_entity
+
+          return unless current_user.present?
+
+          @current_scoped_entity ||= scoped_entity_class
+            .associated_with(current_user)
+            .from_path_param(request.path_parameters[scoped_entity_param_key])
+            .first! # Raise NotFound if user does not have access to the entity or it does not exist
+        end
+
+        def remember_scoped_entity
+          return unless scoped_to_entity?
+
+          session[scoped_entity_session_key] = current_scoped_entity.to_global_id.to_s
+        end
+
+        def remembered_scoped_entity
+          ensure_legal_entity_scoping_method_access! :remembered_scoped_entity
+
+          @remembered_scoped_entity ||= GlobalID::Locator.locate session[scoped_entity_session_key]
+        end
+
+        def ensure_legal_entity_scoping_method_access!(method)
+          return if scoped_to_entity?
+
+          raise NotImplementedError, "this request is not scoped to an entity\n\n" \
+                                     "add the `scope_to_entity YourEntityRecord` directive in " \
+                                     "#{current_engine} or implement #{self.class}##{method}"
+        end
+      end
+    end
+  end
+end

data/lib/plutonium/core/controllers/interactive_actions.rb

@@ -0,0 +1,210 @@
+module Plutonium
+  module Core
+    module Controllers
+      module InteractiveActions
+        extend ActiveSupport::Concern
+
+        included do
+          before_action :validate_interactive_resource_action, only: %i[
+            begin_interactive_resource_record_action commit_interactive_resource_record_action
+            begin_interactive_resource_collection_action commit_interactive_resource_collection_action
+            begin_interactive_resource_recordless_action commit_interactive_resource_recordless_action
+          ]
+
+          before_action :authorize_interactive_resource_record_action, only: %i[
+            begin_interactive_resource_record_action commit_interactive_resource_record_action
+          ]
+
+          before_action :authorize_interactive_resource_action, only: %i[
+            begin_interactive_resource_collection_action commit_interactive_resource_collection_action
+            begin_interactive_resource_recordless_action commit_interactive_resource_recordless_action
+          ]
+        end
+
+        # GET /resources/1/actions/:interactive_action
+        def begin_interactive_resource_record_action
+          @interaction = current_interactive_action.interaction.new interaction_params
+
+          if helpers.current_turbo_frame == "modal"
+            render layout: false
+          else
+            render :interactive_resource_record_action
+          end
+        end
+
+        # POST /resources/1/actions/:interactive_action
+        def commit_interactive_resource_record_action
+          respond_to do |format|
+            inputs = interaction_params.merge(resource: resource_record)
+            @interaction = current_interactive_action.interaction.run(inputs)
+
+            if @interaction.valid?
+              flash[:notice] = "TODO:#{current_interactive_action} was successfully updated."
+
+              format.html { redirect_to adapt_route_args(@interaction.result), status: :see_other }
+              format.any { render :show, status: :ok, location: adapt_route_args(@interaction.result) }
+
+              if helpers.current_turbo_frame == "modal"
+                format.turbo_stream do
+                  render turbo_stream: [
+                    turbo_stream.redirect(url_for(adapt_route_args(@interaction.result)))
+                  ]
+                end
+              end
+            else
+              format.html do
+                render :interactive_resource_record_action, status: :unprocessable_entity
+              end
+              format.any do
+                @errors = @interaction.errors
+                render "errors", status: :unprocessable_entity
+              end
+
+              if helpers.current_turbo_frame == "modal"
+                format.turbo_stream do
+                  render turbo_stream: turbo_stream.replace(:modal, partial: "interactive_resource_record_action_form")
+                end
+              end
+            end
+          end
+        end
+
+        # GET /resources/actions/:interactive_action?ids[]=1&ids[]=2
+        def begin_interactive_resource_collection_action
+          # TODO: ensure that the selected list matches the returned value
+          interactive_resource_collection
+          @interaction = current_interactive_action.interaction.new((params[:interaction] || {}).except(:resources))
+
+          if helpers.current_turbo_frame == "modal"
+            render layout: false
+          else
+            render :interactive_resource_collection_action
+          end
+        end
+
+        # POST /resources/actions/:interactive_action?ids[]=1&ids[]=2
+        def commit_interactive_resource_collection_action
+          respond_to do |format|
+            inputs = interaction_params.merge(resources: interactive_resource_collection)
+            @interaction = current_interactive_action.interaction.run(inputs)
+
+            if @interaction.valid?
+              collection_count = interactive_resource_collection.size
+
+              flash[:notice] = "TODO:#{current_interactive_action} #{collection_count} #{resource_class.model_name.human.pluralize(collection_count)} successfully updated."
+
+              format.html { redirect_to adapt_route_args(resource_class) }
+              if helpers.current_turbo_frame == "modal"
+                format.turbo_stream do
+                  render turbo_stream: [
+                    turbo_stream.redirect(url_for(resource_class))
+                  ]
+                end
+              end
+            else
+              format.html do
+                render :interactive_resource_collection_action, status: :unprocessable_entity
+              end
+              format.any do
+                @errors = @interaction.errors
+                render "errors", status: :unprocessable_entity
+              end
+
+              if helpers.current_turbo_frame == "modal"
+                format.turbo_stream do
+                  render turbo_stream: turbo_stream.replace(:modal, partial: "interactive_resource_collection_action_form")
+                end
+              end
+            end
+          end
+        end
+
+        # GET /resources/actions/:interactive_action
+        def begin_interactive_resource_recordless_action
+          skip_policy_scope
+
+          @interaction = current_interactive_action.interaction.new interaction_params
+
+          if helpers.current_turbo_frame == "modal"
+            render layout: false
+          else
+            render :interactive_resource_recordless_action
+          end
+        end
+
+        # POST /resources/actions/:interactive_action
+        def commit_interactive_resource_recordless_action
+          skip_policy_scope
+
+          respond_to do |format|
+            inputs = interaction_params
+            @interaction = current_interactive_action.interaction.run(inputs)
+
+            if @interaction.valid?
+              flash[:notice] = "TODO:#{current_interactive_action} was successfully updated."
+
+              format.html { redirect_to adapt_route_args(resource_class) }
+
+              if helpers.current_turbo_frame == "modal"
+                format.turbo_stream do
+                  render turbo_stream: [
+                    turbo_stream.redirect(url_for(adapt_route_args(resource_class)))
+                  ]
+                end
+              end
+            else
+              format.html do
+                render :interactive_resource_recordless_action, status: :unprocessable_entity
+              end
+              format.any do
+                @errors = @interaction.errors
+                render "errors", status: :unprocessable_entity
+              end
+
+              if helpers.current_turbo_frame == "modal"
+                format.turbo_stream do
+                  render turbo_stream: turbo_stream.replace(:modal, partial: "interactive_resource_recordless_action_form")
+                end
+              end
+            end
+          end
+        end
+
+        private
+
+        def current_interactive_action
+          @current_interactive_action = interactive_resource_actions[params[:interactive_action].to_sym]
+        end
+
+        def interactive_resource_actions
+          @interactive_resource_actions ||= current_presenter.actions.except :new, :show, :edit, :destroy
+        end
+
+        def validate_interactive_resource_action
+          interactive_resource_action = params[:interactive_action]&.to_sym
+          unless interactive_resource_actions.key?(interactive_resource_action)
+            raise ::AbstractController::ActionNotFound, "Unknown action '#{interactive_resource_action}'"
+          end
+        end
+
+        def authorize_interactive_resource_record_action
+          interactive_resource_action = params[:interactive_action]&.to_sym
+          authorize resource_record, :"#{interactive_resource_action}?"
+        end
+
+        def authorize_interactive_resource_action
+          interactive_resource_action = params[:interactive_action]&.to_sym
+          authorize resource_class, :"#{interactive_resource_action}?"
+        end
+
+        def interactive_resource_collection
+          @interactive_resource_collection ||= policy_scope(resource_class).from_path_param(params.require(:ids)).all
+        end
+
+        def interaction_params
+          (params[:interaction] || {}).except(:resource, :resources)
+        end
+      end
+    end
+  end
+end

data/lib/plutonium/core/controllers/presentable.rb

@@ -0,0 +1,59 @@
+module Plutonium
+  module Core
+    module Controllers
+      module Presentable
+        extend ActiveSupport::Concern
+
+        included do
+          helper_method :presentable_attributes
+        end
+
+        private
+
+        def resource_presenter(resource_class)
+          raise NotImplementedError, "#{self.class}#resource_presenter"
+        end
+
+        def current_presenter
+          resource_presenter resource_class
+        end
+
+        def presentable_attributes
+          @presentable_attributes ||= begin
+            presentable_attributes = permitted_attributes
+            presentable_attributes -= [scoped_entity_param_key, :"#{scoped_entity_param_key}_id"] if scoped_to_entity?
+            presentable_attributes -= [parent_input_param, :"#{parent_input_param}_id"] if current_parent.present?
+            presentable_attributes
+          end
+        end
+
+        def build_collection
+          Plutonium::Core::UI::Collection.new(
+            resource_class:,
+            records: @resource_records,
+            fields: current_presenter.defined_renderers_for(presentable_attributes),
+            actions: current_presenter.actions,
+            pagination: @pagy,
+            search_object: @ransack
+          )
+        end
+
+        def build_detail
+          Plutonium::Core::UI::Detail.new(
+            resource_class:,
+            record: resource_record,
+            fields: current_presenter.defined_renderers_for(presentable_attributes),
+            actions: current_presenter.actions
+          )
+        end
+
+        def build_form
+          Plutonium::Core::UI::Form.new(
+            record: resource_record,
+            inputs: current_presenter.defined_inputs_for(presentable_attributes)
+          )
+        end
+      end
+    end
+  end
+end

data/lib/plutonium/core/controllers.rb

@@ -0,0 +1,16 @@
+module Plutonium
+  module Core
+    module Controllers
+      extend ActiveSupport::Autoload
+
+      eager_autoload do
+        autoload :Authorizable
+        autoload :Bootable
+        autoload :CrudActions
+        autoload :EntityScoping
+        autoload :Presentable
+        autoload :InteractiveActions
+      end
+    end
+  end
+end

data/lib/plutonium/core/definers/action_definer.rb

@@ -0,0 +1,25 @@
+module Plutonium
+  module Core
+    module Definers
+      module ActionDefiner
+        extend ActiveSupport::Concern
+
+        def actions
+          action_definitions
+        end
+
+        private
+
+        def action_definitions = @action_definitions ||= Plutonium::Core::Actions::Collection.new
+
+        def define_action(action)
+          action_definitions[action.name] = action
+        end
+
+        def action_defined?(name)
+          action_definitions.key? name
+        end
+      end
+    end
+  end
+end