plutonium 0.14.1 → 0.15.0.pre.rc1

data/lib/plutonium/core/controller.rb

@@ -0,0 +1,110 @@
+module Plutonium
+  module Core
+    module Controller
+      extend ActiveSupport::Concern
+      include Plutonium::Core::Controllers::Bootable
+      include Plutonium::Core::Controllers::EntityScoping
+      include Plutonium::Core::Controllers::Authorizable
+
+      included do
+        add_flash_types :success, :warning, :error
+
+        before_action do
+          next unless defined?(ActiveStorage)
+
+          ActiveStorage::Current.url_options = {protocol: request.protocol, host: request.host, port: request.port}
+        end
+
+        helper Plutonium::Helpers
+        helper_method :make_page_title, :resource_url_for, :resource_url_args_for, :root_path
+
+        append_view_path File.expand_path("app/views", Plutonium.root)
+        layout -> { turbo_frame_request? ? false : "resource" }
+        helper_method :registered_resources
+      end
+
+      private
+
+      def set_page_title(page_title)
+        @page_title = page_title
+      end
+
+      def make_page_title(title)
+        [title.presence, helpers.application_name].compact.join(" | ")
+      end
+
+      #
+      # Returns a dynamic list of args to be used with `url_for`, which considers the route namespace and nesting.
+      # The current entity and parent record (for nested routes) are inserted appropriately, ensuring that generated URLs
+      # obey the current routing.
+      #
+      # e.g., of route helpers that will be invoked given the output of this method
+      #
+      # - when invoked in a root route (/acme/dashboard/users)
+      #
+      # `resource_url_args_for User`                   => `entity_users_*`
+      # `resource_url_args_for @user`                  => `entity_user_*`
+      # `resource_url_args_for @user, action: :edit`   => `edit_entity_user_*`
+      # `resource_url_args_for @user, Post`            => `entity_user_posts_*`
+      #
+      # - when invoked in a nested route (/acme/dashboard/users/1/post/1)
+      #
+      # `resource_url_args_for Post`                   => `entity_user_posts_*`
+      # `resource_url_args_for @post`                  => `entity_user_post_*`
+      # `resource_url_args_for @post, action: :edit`   => `edit_entity_user_post_*`
+      #
+      # @param [Class, ApplicationRecord] *args arguments you would normally pass to `url_for`
+      # @param [Symbol] action optional action to invoke, e.g., :new, :edit
+      # @param [ApplicationRecord] parent the parent record for nested routes, if any
+      # @param [Hash] kwargs additional keyword arguments to pass to `url_for`
+      #
+      # @return [Hash] args to pass to `url_for`
+      #
+      def resource_url_args_for(*args, action: nil, parent: nil, **kwargs)
+        url_args = {**kwargs, action: action}.compact
+
+        controller_chain = [current_package&.to_s].compact
+        [*args].compact.each_with_index do |element, index|
+          if element.is_a?(Class)
+            controller_chain << element.to_s.pluralize
+          else
+            controller_chain << element.class.to_s.pluralize
+            if index == args.length - 1
+              url_args[:id] = element.to_param
+              url_args[:action] ||= :show
+            else
+              url_args[element.model_name.singular_route_key.to_sym] = element.to_param
+            end
+          end
+        end
+        url_args[:controller] = "/#{controller_chain.join("::").underscore}"
+
+        url_args[:"#{parent.model_name.singular_route_key}_id"] = parent.to_param if parent.present?
+        if scoped_to_entity? && scoped_entity_strategy == :path
+          url_args[scoped_entity_param_key] = current_scoped_entity
+        end
+
+        url_args
+      end
+
+      def resource_url_for(...)
+        args = resource_url_args_for(...)
+        if current_package.present?
+          send(current_package.name.underscore.to_sym).url_for(args)
+        else
+          url_for(args)
+        end
+      end
+
+      def root_path(*)
+        return send(:"#{scoped_entity_param_key}_root_path", *) if scoped_to_entity? && scoped_entity_strategy == :path
+
+        super(*)
+      end
+
+      def registered_resources
+        current_engine.resource_register.resources
+      end
+    end
+  end
+end

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

@@ -1,56 +1,33 @@
-require "pundit"
+# frozen_string_literal: true
 
 module Plutonium
   module Core
     module Controllers
       module Authorizable
         extend ActiveSupport::Concern
-        include ::Pundit::Authorization
+        include ActionPolicy::Controller
 
         included do
-          after_action :verify_authorized
-          after_action :verify_policy_scoped, except: %i[new create]
+          authorize :user, through: :current_user
+          authorize :scope, through: :entity_scope_for_authorize
 
-          helper_method :current_policy, :permitted_attributes
+          helper_method :policy_for, :authorized_resource_scope
         end
 
         private
 
-        def policy_context
-          raise NotImplementedError, "policy_context"
-        end
-
-        def pundit_user
-          policy_context
-        end
+        def authorized_resource_scope(resource, **options)
+          raise ArgumentError("Expected resource to be a class inheriting ActiveRecord::Base") unless resource.instance_of?(Class) && resource < ActiveRecord::Base
 
-        # @return [Plutonium::Pundit::Context] a new instance of {Plutonium::Pundit::Context} with the current user and package
-        def pundit
-          @pundit ||= Plutonium::Pundit::Context.new(
-            package: current_package.to_s.underscore.to_sym,
-            user: pundit_user,
-            policy_cache: ::Pundit::CacheStore::LegacyStore.new(policies)
-          )
-        end
+          options[:with] ||= ActionPolicy.lookup(resource, namespace: authorization_namespace)
+          resource = resource.all
 
-        def permitted_attributes
-          @permitted_attributes ||= current_policy.send_with_report :"permitted_attributes_for_#{action_name}"
+          authorized_scope(resource, **options)
         end
 
-        def permitted_associations
-          @permitted_associations ||= current_policy.permitted_associations
+        def entity_scope_for_authorize
+          scoped_to_entity? ? current_scoped_entity : nil
         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

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

@@ -3,21 +3,52 @@ module Plutonium
     module Controllers
       module Bootable
         extend ActiveSupport::Concern
+        include Plutonium::Engine::Validator
 
         included do
-          class_attribute :current_package, instance_writer: false, instance_predicate: false
-          class_attribute :current_engine, instance_writer: false, instance_predicate: false
+          helper_method :current_package, :current_engine
+        end
+
+        def current_package
+          self.class.current_package
+        end
 
-          helper_method :current_engine, :current_package
+        def current_engine
+          self.class.current_engine
         end
 
         class_methods do
-          def boot(package)
-            self.current_package = package
-            self.current_engine = "#{package}::Engine".constantize
+          include Plutonium::Lib::SmartCache
+
+          def inherited(subclass)
+            super
+
+            subclass.boot
+          end
+
+          def boot(package = nil)
+            if package.present?
+              Plutonium.deprecator.warn(
+                "Calling boot with an argument is deprecated and no longer has an effect.",
+                caller_locations(1)
+              )
+            end
+
+            if current_engine != Rails.application.class
+              prepend_view_path current_engine.paths["app/views"].first
+            end
+          end
+
+          def current_package
+            (current_engine == Rails.application.class) ? nil : current_engine.module_parent
+          end
+          memoize_unless_reloading :current_package
 
-            prepend_view_path current_engine.paths["app/views"].first
+          def current_engine
+            potential_package = module_parents[-2]
+            potential_package.nil? ? Rails.application.class : ("#{potential_package}::Engine".safe_constantize || Rails.application.class)
           end
+          memoize_unless_reloading :current_engine
         end
       end
     end

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

@@ -60,7 +60,7 @@ module Plutonium
         # @raise [NotImplementedError] if not scoped to an entity
         def scoped_entity_session_key
           ensure_legal_entity_scoping_method_access!(__method__)
-          :"#{current_package.name.underscore}__scoped_entity_id"
+          [current_package&.name&.underscore, "scoped_entity_id"].compact.join("__").to_sym
         end
 
         # Returns the current scoped entity for the request.
@@ -69,6 +69,8 @@ module Plutonium
         # @raise [NotImplementedError] if not scoped to an entity or strategy is unknown
         def current_scoped_entity
           ensure_legal_entity_scoping_method_access!(__method__)
+          # this method might be invoked even when not authenticated.
+          # so let's guard against that.
           return unless current_user.present?
 
           @current_scoped_entity ||= fetch_current_scoped_entity
@@ -79,7 +81,7 @@ module Plutonium
         # @return [ActiveRecord::Base, nil] the current scoped entity or nil if not found
         # @raise [NotImplementedError] if the scoping strategy is unknown
         def fetch_current_scoped_entity
-          case scoped_entity_strategy
+          scoped_entity = case scoped_entity_strategy
           when :path
             fetch_entity_from_path
           when Symbol
@@ -87,6 +89,8 @@ module Plutonium
           else
             raise NotImplementedError, "Unknown scoped entity strategy: #{scoped_entity_strategy.inspect}"
           end
+          authorize! scoped_entity, to: :read?
+          scoped_entity
         end
 
         # Fetches the scoped entity from the path parameters.

data/lib/plutonium/core/fields/renderers/association_renderer.rb

@@ -18,7 +18,7 @@ module Plutonium
 
           def renderer_options
             {
-              helper: value.class.include?(Plutonium::Resource::Record) ? :display_association_value : :display_name_of
+              # helper: value.class.include?(Plutonium: :Resource: :Record) ? :display_association_value : :display_name_of
             }
           end
         end

data/lib/plutonium/core/ui/collection.rb

@@ -2,7 +2,7 @@ require "dry-initializer"
 
 module Plutonium
   module Core
-    module Ui
+    module UI
       class Collection
         extend Dry::Initializer
 

data/lib/plutonium/core/ui/detail.rb

@@ -1,6 +1,6 @@
 module Plutonium
   module Core
-    module Ui
+    module UI
       class Detail
         extend Dry::Initializer
 

data/lib/plutonium/core/ui/form.rb

@@ -1,6 +1,6 @@
 module Plutonium
   module Core
-    module Ui
+    module UI
       class Form
         extend Dry::Initializer
 

data/lib/plutonium/definition/actions.rb

@@ -0,0 +1,50 @@
+module Plutonium
+  module Definition
+    module Actions
+      extend ActiveSupport::Concern
+
+      included do
+        defineable_prop :action
+
+        def self.action(name, interaction: nil, **)
+          defined_actions[name] = if interaction
+            Plutonium::Action::Interactive::Factory.create(name, interaction:, **)
+          else
+            Plutonium::Action::Simple.new(name, **)
+          end
+        end
+
+        def action(name, **)
+          instance_defined_actions[name] = Plutonium::Action::Simple.new(name, **)
+        end
+
+        def defined_actions
+          @merged_defined_actions ||= begin
+            customize_actions
+            merged = self.class.defined_actions.merge(instance_defined_actions)
+            merged.sort_by { |k, v| v.position }.to_h
+          end
+        end
+
+        # standard CRUD actions
+
+        action(:new, route_options: {action: :new},
+          resource_action: true, category: :primary,
+          icon: Phlex::TablerIcons::Plus, position: 10)
+
+        action(:show, route_options: {action: :show},
+          collection_record_action: true,
+          icon: Phlex::TablerIcons::Eye, position: 10)
+
+        action(:edit, route_options: {action: :edit},
+          record_action: true, collection_record_action: true,
+          icon: Phlex::TablerIcons::Edit, position: 20)
+
+        action(:destroy, route_options: {method: :delete},
+          record_action: true, collection_record_action: true, category: :danger,
+          icon: Phlex::TablerIcons::Trash, position: 100,
+          confirmation: "Are you sure?", turbo_frame: "_top")
+      end
+    end
+  end
+end

data/lib/plutonium/definition/base.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module Plutonium
+  module Definition
+    # Base class for Plutonium definitions
+    #
+    # @abstract Subclass and override {#customize_fields}, {#customize_inputs},
+    #   {#customize_filters}, {#customize_scopes}, and {#customize_sorters}
+    #   to implement custom behavior.
+    #
+    # @example
+    #   class MyDefinition < Plutonium::Definition::Base
+    #     field :name, as: :string
+    #     input :email, as: :email
+    #     filter :status, type: :select, collection: %w[active inactive]
+    #     scope :active, default: true
+    #     sorter :created_at
+    #
+    #     def customize_fields
+    #       field :custom_field, as: :integer
+    #     end
+    #   end
+    #
+    # @note This class is not thread-safe. Ensure proper synchronization
+    #   if used in a multi-threaded environment.
+    class Base
+      include DefineableProps
+      include ConfigAttr
+      include Actions
+      include Search
+
+      class IndexPage < Plutonium::UI::Page::Index; end
+
+      class NewPage < Plutonium::UI::Page::New; end
+
+      class ShowPage < Plutonium::UI::Page::Show; end
+
+      class EditPage < Plutonium::UI::Page::Edit; end
+
+      class Form < Plutonium::UI::Form::Resource; end
+
+      class Table < Plutonium::UI::Table::Resource; end
+
+      class Display < Plutonium::UI::Display::Resource; end
+
+      # fields
+      defineable_props :field, :input, :display, :column
+
+      # queries
+      defineable_props :filter, :scope, :sort
+
+      # pages
+      config_attr \
+        :index_page_title, :index_page_description,
+        :show_page_title, :show_page_description,
+        :new_page_title, :new_page_description,
+        :edit_page_title, :edit_page_description
+
+      def initialize
+        super
+      end
+
+      def index_page_class
+        self.class::IndexPage
+      end
+
+      def new_page_class
+        self.class::NewPage
+      end
+
+      def show_page_class
+        self.class::ShowPage
+      end
+
+      def edit_page_class
+        self.class::EditPage
+      end
+
+      def form_class
+        self.class::Form
+      end
+
+      def collection_class
+        self.class::Table
+      end
+
+      def detail_class
+        self.class::Display
+      end
+    end
+  end
+end

data/lib/plutonium/definition/config_attr.rb

@@ -0,0 +1,30 @@
+module Plutonium
+  module Definition
+    module ConfigAttr
+      extend ActiveSupport::Concern
+
+      class_methods do
+        def config_attr(*names)
+          names.each do |name|
+            define_singleton_method(name) do |value = :__this_is_so_nilly__|
+              if value == :__this_is_so_nilly__
+                # Getter behavior
+                # if singleton_class.instance_variable_defined?(:"@#{name}")
+                singleton_class.instance_variable_get(:"@#{name}")
+                # end
+              else
+                # Setter behavior
+                singleton_class.instance_variable_set(:"@#{name}", value)
+              end
+            end
+
+            # Instance-level method
+            define_method(name) do
+              self.class.send(name)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/plutonium/definition/defineable_props.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+module Plutonium
+  module Definition
+    # Module for handling defineable properties in Plutonium definitions
+    #
+    # @example
+    #   class MyDefinition
+    #     include DefineableProperties
+    #
+    #     defineable_property :field
+    #     defineable_property :input
+    #     defineable_property :filter
+    #     defineable_property :scope
+    #     defineable_property :sorter
+    #   end
+    module DefineableProps
+      extend ActiveSupport::Concern
+
+      included do
+        class_attribute :_defineable_props_store, instance_accessor: false, instance_predicate: false, default: []
+      end
+
+      class_methods do
+        def defineable_props(*property_names)
+          property_names.each { |name| defineable_prop(name) }
+        end
+
+        # Defines a new property type for the class
+        #
+        # @param property_name [Symbol] The name of the property to define
+        # @return [void]
+        def defineable_prop(property_name)
+          property_plural = property_name.to_s.pluralize.to_sym
+          property_getter = :"defined_#{property_plural}"
+          self._defineable_props_store += [property_plural]
+
+          class_eval <<-RUBY, __FILE__, __LINE__ + 1
+            def self.#{property_name}(name, **options, &block)
+              #{property_getter}[name] = { options:, block:}.compact
+            end
+
+            def self.#{property_getter}
+              @#{property_getter} ||= {}
+            end
+
+            def #{property_name}(name, **options, &block)
+              instance_#{property_getter}[name] = { options:, block:}.compact
+            end
+
+            def #{property_getter}
+              @merged_#{property_getter} ||= begin
+                customize_#{property_plural}
+                merged = {}
+                self.class.#{property_getter}.each do |name, data|
+                  merged[name] = {
+                    options: data[:options].dup,
+                    block: data[:block]
+                  }.compact
+                end
+                instance_#{property_getter}.each do |name, data|
+                  if merged.key?(name)
+                    merged[name][:options].merge!(data[:options])
+                    merged[name][:block] = data[:block] if data[:block]
+                  else
+                    merged[name] = data
+                  end
+                  # merged[name].compact!
+                end
+                merged
+              end
+            end
+
+            def customize_#{property_plural}
+              # Override in subclass to add or modify #{property_plural}
+            end
+
+            private
+
+            def instance_#{property_getter}
+              @instance_#{property_getter} ||= {}
+            end
+          RUBY
+        end
+
+        # Handles inheritance by duplicating class-level collections
+        def inherited(subclass)
+          super
+          _defineable_props_store.each do |property|
+            subclass.instance_variable_set(:"@defined_#{property}", instance_variable_get(:"@defined_#{property}")&.deep_dup || {})
+          end
+        end
+      end
+    end
+  end
+end

data/lib/plutonium/definition/search.rb

@@ -0,0 +1,21 @@
+module Plutonium
+  module Definition
+    module Search
+      extend ActiveSupport::Concern
+
+      included do
+        class_attribute :_search_definition, instance_accessor: false, instance_predicate: false
+      end
+
+      def search_definition
+        self.class._search_definition
+      end
+
+      class_methods do
+        def search(&block)
+          self._search_definition = block
+        end
+      end
+    end
+  end
+end

data/lib/plutonium/engine/validator.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Plutonium
+  module Engine
+    module Validator
+      extend ActiveSupport::Concern
+
+      class_methods do
+        # Validates that the current engine supports Plutonium features.
+        #
+        # @raise [ArgumentError] If the engine doesn't include Plutonium::Engine.
+        # @return [void]
+        def validate_engine!(engine)
+          return if supported_engine?(engine)
+
+          # TODO: make the error link to documentation on how to ensure that your engine is supported
+          raise ArgumentError, "#{engine} must include Plutonium::Engine to call register resources"
+        end
+
+        # Checks if the current engine supports Plutonium features.
+        #
+        # @return [Boolean] True if the engine includes Plutonium::Engine, false otherwise.
+        def supported_engine?(engine)
+          # TODO: fix constant being out of sync after reload during development
+          Plutonium.configuration.development? ? engine.respond_to?(:dom_id) : engine.include?(Plutonium::Engine)
+        end
+      end
+    end
+  end
+end

data/lib/plutonium/engine.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Plutonium
+  module Engine
+    extend ActiveSupport::Concern
+
+    class_methods do
+      attr_reader :scoped_entity_class, :scoped_entity_strategy, :scoped_entity_param_key
+
+      def scope_to_entity(entity_class, strategy: :path, param_key: nil)
+        @scoped_entity_class = entity_class
+        @scoped_entity_strategy = strategy
+        @scoped_entity_param_key = param_key || entity_class.model_name.singular_route_key.to_sym
+      end
+
+      def scoped_to_entity?
+        scoped_entity_class.present?
+      end
+
+      def dom_id
+        module_parent_name.underscore.dasherize
+      end
+    end
+  end
+end

data/lib/plutonium/helpers/form_helper.rb

@@ -1,5 +1,3 @@
-require "view_component/form"
-
 module Plutonium
   module Helpers
     module FormHelper
@@ -23,7 +21,7 @@ module Plutonium
 
       def token_tag(...)
         # needed to workaround https://github.com/tailwindlabs/tailwindcss/issues/3350
-        super(...).sub(" />", " hidden />").html_safe
+        super.sub(" />", " hidden />").html_safe
       end
 
       private