plutonium 0.14.0 → 0.15.0.pre.rc1

data/lib/plutonium/configuration.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+module Plutonium
+  # Configuration class for Plutonium module
+  #
+  # @example
+  #   Plutonium.configure do |config|
+  #     config.load_defaults 1.0
+  #     config.development = true
+  #     config.cache_discovery = false
+  #     config.enable_hotreload = true
+  #     config.assets.logo = "custom_logo.png"
+  #   end
+  class Configuration
+    # @return [Boolean] whether Plutonium is in development mode
+    attr_accessor :development
+
+    # @return [Boolean] whether to cache discovery
+    attr_accessor :cache_discovery
+
+    # @return [Boolean] whether to enable hot reloading
+    attr_accessor :enable_hotreload
+
+    # @return [AssetConfiguration] asset configuration
+    attr_reader :assets
+
+    # @return [Float] the current defaults version
+    attr_reader :defaults_version
+
+    # Map of version numbers to their default configurations
+    VERSION_DEFAULTS = {
+      1.0 => proc do |config|
+        # No changes for 1.0 yet as it's the current base configuration
+      end
+      # Add more version configurations here as needed
+      # 1.1 => proc do |config|
+      #   config.some_new_setting = true
+      # end
+    }.freeze
+
+    # Initialize a new Configuration instance
+    #
+    # @note This method sets initial values
+    def initialize
+      @defaults_version = nil
+      @assets = AssetConfiguration.new
+
+      @development = parse_boolean_env("PLUTONIUM_DEV")
+      @cache_discovery = !Rails.env.development?
+      @enable_hotreload = Rails.env.development?
+    end
+
+    # Load default configuration for a specific version
+    #
+    # @param version [Float] the version to load defaults for
+    # @return [void]
+    def load_defaults(version)
+      available_versions = VERSION_DEFAULTS.keys.sort
+      applicable_versions = available_versions.select { |v| v <= version }
+
+      if applicable_versions.empty?
+        raise "No applicable defaults found for version #{version}."
+      end
+
+      applicable_versions.each do |v|
+        VERSION_DEFAULTS[v].call(self)
+      end
+
+      @defaults_version = applicable_versions.last
+    end
+
+    # whether Plutonium is in development mode
+    #
+    # @return [Boolean]
+    def development?
+      @development
+    end
+
+    private
+
+    # Parse boolean environment variable
+    #
+    # @param env_var [String] name of the environment variable
+    # @return [Boolean] parsed boolean value
+    def parse_boolean_env(env_var)
+      ActiveModel::Type::Boolean.new.cast(ENV[env_var]).present?
+    end
+
+    # Asset configuration for Plutonium
+    class AssetConfiguration
+      # @return [String] path to logo file
+      attr_accessor :logo
+
+      # @return [String] path to favicon file
+      attr_accessor :favicon
+
+      # @return [String] path to stylesheet file
+      attr_accessor :stylesheet
+
+      # @return [String] path to JavaScript file
+      attr_accessor :script
+
+      # Initialize a new AssetConfiguration instance with default values
+      def initialize
+        @logo = "plutonium.png"
+        @favicon = "plutonium.ico"
+        @stylesheet = "plutonium.css"
+        @script = "plutonium.min.js"
+      end
+    end
+  end
+
+  class << self
+    # Get the current configuration
+    #
+    # @return [Configuration] current configuration instance
+    def configuration
+      @configuration ||= Configuration.new
+    end
+
+    # Configure Plutonium
+    #
+    # @yield [config] Configuration instance
+    # @yieldparam config [Configuration] current configuration instance
+    # @return [void]
+    def configure
+      yield(configuration)
+    end
+  end
+end

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

@@ -9,7 +9,7 @@ module Plutonium
         end
 
         def permitted_for(policy)
-          Collection.new(@collection.select { |name, action| policy.send_with_report :"#{action.name}?" })
+          Collection.new(@collection.select { |name, action| policy.allowed_to? :"#{action.name}?" })
         end
 
         def collection_actions

data/lib/plutonium/core/associations/renderers/factory.rb

@@ -19,7 +19,9 @@ module Plutonium
           def self.for_resource_association(resource_class, attr_name, **options)
             association = resource_class.try(:reflect_on_association, attr_name)
             raise ArgumentError, "#{attr_name} is not a valid association of #{resource_class}" unless association.present?
-            raise ArgumentError, "#{association.klass} does is not a resource record" unless association.klass.include?(Plutonium::Resource::Record)
+            # # TODO: fix constant being out of sync after reload during development
+            # valid_resource_record = Plutonium.configuration.development? ? association.klass.respond_to?(:resource_field_names) : association.klass.include?(Plutonium: :Resource: :Record)
+            # raise ArgumentError, "#{association.klass} is not a resource record" unless valid_resource_record
 
             type = association.macro
             raise NotImplementedError, "#{macro} associations are currently not supported." unless type == :has_many

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

@@ -14,7 +14,7 @@ module Plutonium
         # If cache_discovery is enabled, use the class level cache that persists
         # between requests, otherwise use the instance one.
         def autodiscovery_association_renderer_cache
-          if Rails.application.config.plutonium.cache_discovery
+          if Plutonium.configuration.cache_discovery
             self.class.autodiscovery_association_renderer_cache
           else
             @autodiscovery_association_renderer_cache ||= {}

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

@@ -14,7 +14,7 @@ module Plutonium
         # If cache_discovery is enabled, use the class level cache that persists
         # between requests, otherwise use the instance one.
         def autodiscovery_input_cache
-          if Rails.application.config.plutonium.cache_discovery
+          if Plutonium.configuration.cache_discovery
             self.class.autodiscovery_input_cache
           else
             @autodiscovery_input_cache ||= {}

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

@@ -14,7 +14,7 @@ module Plutonium
         # If cache_discovery is enabled, use the class level cache that persists
         # between requests, otherwise use the instance one.
         def autodiscovery_renderer_cache
-          if Rails.application.config.plutonium.cache_discovery
+          if Plutonium.configuration.cache_discovery
             self.class.autodiscovery_renderer_cache
           else
             @autodiscovery_renderer_cache ||= {}

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