plutonium 0.13.3 → 0.14.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d53d01dfc30698f6bc1b3493db5509baab84b07fa49b4539ff18f6b033336982
-  data.tar.gz: 45b8cf3a4d0f2b022ce5ad495d519724175bc62eda2c783851bf4b5d44e2e958
+  metadata.gz: 2a68eccc72cf54155fa9d9959a22b60d13ea434a4faf34221ec0314e5ab74124
+  data.tar.gz: 99c748e56b3b07eb7361f67887137430eef9cb35a3e0b3bd04c1de831ae68b04
 SHA512:
-  metadata.gz: a59752cd033c146756b2a330f7e42bc7ae526570cc9851c26fec6daabbf5fe41794c0069b0a21f4c5a9ea4425f5ddb4a7d90d1df89097db700231bd119dcb9c0
-  data.tar.gz: 1e64998368c580cd5a52a0c22c1e7df3a883e963a32a2f65b5e6f390a9b3e2d9cda19f568091a0c9cf2e0bea06f66ab459e25c7eb8672d86880aa83008b1c844
+  metadata.gz: 6ada4ff77eddc1daa695bd4ff96542f5f72b378ab7826c99f256faa089182c9084edd5db2433d044d6270df5714097e9e46add301631446ead9c1ae034ead0b9
+  data.tar.gz: e600eb51acf5873891b4c38b4541e1220c4e62f19eb74b9194c68203e73e0178d3e6ef74ee9437daf9dd27ced14b93ebe2807d3f4338b160e3de26dddd21691b

data/lib/generators/pu/pkg/app/templates/config/routes.rb.tt

@@ -1,11 +1,10 @@
-<%= package_name %>::Engine.draw_custom_routes do
-  # draw custom routes here
-
+<%= package_name %>::Engine.routes.draw do
   root to: "dashboard#index"
-end
 
-# draw routes for registered resources
-<%= package_name %>::Engine.draw_resource_routes
+  # register resources above.
+
+  # Define your application routes per the DSL in https://guides.rubyonrails.org/routing.html
+end
 
 # mount our app
 Rails.application.routes.draw do

data/lib/generators/pu/pkg/app/templates/lib/engine.rb.tt

@@ -4,11 +4,7 @@ module <%= package_name %>
     # add concerns above.
 
     config.after_initialize do
-      initialize_register!
-
       # add directives above.
-
-      # register resources above.
     end
   end
 end

data/lib/generators/pu/res/conn/conn_generator.rb

@@ -15,13 +15,13 @@ module Pu
 
       def start
         source_feature = select_feature msg: "Select source feature"
-        source_module = (source_feature == "main_app") ? "ResourceRecord" : "#{source_feature.classify}::ResourceRecord"
+        source_module = (source_feature == "main_app") ? "ResourceRecord" : "#{source_feature.camelize}::ResourceRecord"
 
         Plutonium.eager_load_rails!
         available_resources = source_module.constantize.descendants.map(&:to_s).sort
         selected_resources = prompt.multi_select("Select resources", available_resources)
 
-        @app_namespace = select_app.classify
+        @app_namespace = select_app.camelize
 
         selected_resources.each do |resource|
           @resource_class = resource
@@ -31,8 +31,8 @@ module Pu
           # template "app/presenters/resource_presenter.rb", "packages/#{package_namespace}/app/presenters/#{package_namespace}/#{resource.underscore}_presenter.rb"
           # template "app/query_objects/resource_query_object.rb", "packages/#{package_namespace}/app/query_objects/#{package_namespace}/#{resource.underscore}_query_object.rb"
 
-          insert_into_file "packages/#{package_namespace}/lib/engine.rb",
-            indent("register_resource ::#{resource}\n", 6),
+          insert_into_file "packages/#{package_namespace}/config/routes.rb",
+            indent("register_resource ::#{resource}\n", 2),
             before: /.*# register resources above.*/
         end
       rescue => e

data/lib/plutonium/application/controller.rb

@@ -36,7 +36,7 @@ module Plutonium
       # end
 
       def registered_resources
-        current_engine.resource_register
+        current_engine.resource_register.resources
       end
     end
   end

data/lib/plutonium/application/dynamic_controllers.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+module Plutonium
+  module Application
+    # DynamicControllers module provides functionality for dynamically creating controller classes
+    # when they are missing in the current module's namespace.
+    #
+    # @example Usage
+    #   module MyApp
+    #     include Plutonium::Application::DynamicControllers
+    #   end
+    #
+    #   # Now, MyApp::SomeController will be dynamically created if it doesn't exist,
+    #   # inheriting from ::SomeController and including MyApp::Concerns::Controller
+    #
+    # @note This module is designed to be included in a parent module that represents
+    #   a namespace for controllers.
+    module DynamicControllers
+      extend ActiveSupport::Concern
+
+      class_methods do
+        # Handles missing constant lookup, specifically for controller classes
+        #
+        # @param const_name [Symbol] The name of the missing constant
+        # @return [Class, nil] The dynamically created controller class if applicable, otherwise nil
+        # @raise [NameError] If the constant is not a controller and cannot be found
+        def const_missing(const_name)
+          if const_name.to_s.end_with?("Controller")
+            create_dynamic_controller(const_name)
+          else
+            super
+          end
+        end
+
+        private
+
+        # Creates a dynamic controller class
+        #
+        # @param const_name [Symbol] The name of the controller class to create
+        # @return [Class] The newly created controller class
+        # @raise [NameError] If the parent controller or concerns module cannot be found
+        def create_dynamic_controller(const_name)
+          parent_controller = "::#{const_name}".constantize
+          current_module = name
+          const_full_name = "#{current_module}::#{const_name}"
+
+          klass = Class.new(parent_controller) do
+            # YARD documentation for the dynamically created controller
+            # @!parse
+            #   class DynamicController < ParentController
+            #     include ParentModule::Concerns::Controller
+            #     # Dynamically created controller for handling actions in the parent module
+            #     #
+            #     # This controller is created at runtime to handle requests within the parent namespace.
+            #     # It inherits from the corresponding top-level controller (e.g., ::ClientsController for ParentModule::ClientsController).
+            #     # It also includes ParentModule::Concerns::Controller.
+            #     #
+            #     # @note This class is created dynamically and may not have explicit method definitions.
+            #   end
+          end
+
+          # Define the constant in the global namespace
+          define_nested_constant(const_full_name, klass)
+
+          # Include required modules
+          concerns_module = "#{current_module}::Concerns::Controller".constantize
+          route_helpers_module = "#{AdminApp}::Engine".constantize.routes.url_helpers
+          klass.include route_helpers_module
+          klass.include concerns_module
+
+          # # Run the load hooks to include necessary modules and configurations
+          # ActiveSupport.run_load_hooks(:action_controller, klass)
+
+          log_controller_creation(const_full_name, parent_controller)
+          const_full_name.constantize
+        rescue => e
+          Plutonium.logger.error "[plutonium] Failed to create dynamic controller: #{e.message}"
+          raise
+        end
+
+        # Defines a constant in the global namespace, handling nested modules
+        #
+        # @param const_full_name [String] The full module name
+        # @param value [Object] The value to assign to the constant
+        def define_nested_constant(const_full_name, value)
+          names = const_full_name.split("::")
+          const_name = names.pop
+
+          names.inject(Object) do |mod, name|
+            if mod.const_defined?(name)
+              mod.const_get(name)
+            else
+              mod.const_set(name, Module.new)
+            end
+          end.const_set(const_name, value)
+        end
+
+        # Logs the creation of a dynamic controller
+        #
+        # @param const_full_name [String] The full name of the created controller
+        # @param parent_controller [Class] The parent controller class
+        def log_controller_creation(const_full_name, parent_controller)
+          Plutonium.logger.info "[plutonium] Dynamically created #{const_full_name} < #{parent_controller}"
+        end
+      end
+    end
+  end
+end

data/lib/plutonium/auth/rodauth.rb

@@ -28,7 +28,7 @@ module Plutonium
           end
 
           define_singleton_method(:to_s) { "Plutonium::Auth::Rodauth(:#{name})" }
-          define_singleton_method(:inspect) { "Plutonium::Auth::Rodautht(:#{name})" }
+          define_singleton_method(:inspect) { "Plutonium::Auth::Rodauth(:#{name})" }
         RUBY
         mod
       end

data/lib/plutonium/concerns/resource_validatable.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Plutonium
+  module Concerns
+    # Provides methods for validating Plutonium resources
+    module ResourceValidatable
+      extend ActiveSupport::Concern
+
+      # Custom error class for invalid resources
+      class InvalidResourceError < StandardError; end
+
+      private
+
+      # Validates if a given resource is a valid Plutonium::Resource::Record
+      #
+      # @param resource [Object] The resource to validate
+      # @raise [InvalidResourceError] If the resource is not valid
+      # @return [void]
+      def validate_resource!(resource)
+        unless valid_resource?(resource)
+          raise InvalidResourceError, "#{resource} is not a valid Plutonium::Resource::Record"
+        end
+      end
+
+      # Checks if a given resource is a valid Plutonium::Resource::Record
+      #
+      # @param resource [Object] The resource to check
+      # @return [Boolean] True if the resource is valid, false otherwise
+      def valid_resource?(resource)
+        resource.is_a?(Class) && resource.include?(Plutonium::Resource::Record)
+      end
+    end
+  end
+end

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

@@ -1,6 +1,17 @@
+# frozen_string_literal: true
+
 module Plutonium
   module Core
     module Controllers
+      # EntityScoping module provides functionality for scoping controllers to specific entities.
+      #
+      # This module is designed to be included in controllers that need to operate within the context
+      # of a specific entity, such as a user's organization or a project.
+      #
+      # @example Usage in a controller
+      #   class MyController < ApplicationController
+      #     include Plutonium::Core::Controllers::EntityScoping
+      #   end
       module EntityScoping
         extend ActiveSupport::Concern
 
@@ -9,70 +20,117 @@ module Plutonium
           helper_method :current_scoped_entity
         end
 
-        private
-
+        # Checks if the current engine is scoped to an entity.
+        #
+        # @return [Boolean] true if scoped to an entity, false otherwise
         def scoped_to_entity?
           current_engine.scoped_to_entity?
         end
 
+        # Returns the strategy used for entity scoping.
+        #
+        # @return [Symbol] the scoping strategy
         def scoped_entity_strategy
           current_engine.scoped_entity_strategy
         end
 
-        def scoped_entity_class
-          ensure_legal_entity_scoping_method_access! :scoped_entity_class
+        # Returns the parameter key used for entity scoping.
+        #
+        # @return [Symbol] the parameter key
+        # @raise [NotImplementedError] if not scoped to an entity
+        def scoped_entity_param_key
+          ensure_legal_entity_scoping_method_access!(__method__)
+          current_engine.scoped_entity_param_key
+        end
 
+        # Returns the class of the scoped entity.
+        #
+        # @return [Class] the scoped entity class
+        # @raise [NotImplementedError] if not scoped to an entity
+        def scoped_entity_class
+          ensure_legal_entity_scoping_method_access!(__method__)
           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
+        private
 
+        # Returns the session key used to store the scoped entity.
+        #
+        # @return [Symbol] the session key
+        # @raise [NotImplementedError] if not scoped to an entity
         def scoped_entity_session_key
-          ensure_legal_entity_scoping_method_access! :scoped_entity_session_key
-
+          ensure_legal_entity_scoping_method_access!(__method__)
           :"#{current_package.name.underscore}__scoped_entity_id"
         end
 
+        # Returns the current scoped entity for the request.
+        #
+        # @return [ActiveRecord::Base, nil] the current scoped entity or nil if not found
+        # @raise [NotImplementedError] if not scoped to an entity or strategy is unknown
         def current_scoped_entity
-          ensure_legal_entity_scoping_method_access! :current_scoped_entity
-
+          ensure_legal_entity_scoping_method_access!(__method__)
           return unless current_user.present?
 
-          @current_scoped_entity ||= case scoped_entity_strategy
+          @current_scoped_entity ||= fetch_current_scoped_entity
+        end
+
+        # Fetches the current scoped entity based on the scoping strategy.
+        #
+        # @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
           when :path
-            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
+            fetch_entity_from_path
           when Symbol
-            send scoped_entity_strategy
+            send(scoped_entity_strategy)
           else
-            raise NotImplementedError, "unknown scoped entity strategy: #{scoped_entity_strategy.inspect}"
+            raise NotImplementedError, "Unknown scoped entity strategy: #{scoped_entity_strategy.inspect}"
           end
         end
 
+        # Fetches the scoped entity from the path parameters.
+        #
+        # @return [ActiveRecord::Base] the scoped entity
+        # @raise [ActiveRecord::RecordNotFound] if the entity is not found or the user doesn't have access
+        def fetch_entity_from_path
+          scoped_entity_class
+            .associated_with(current_user)
+            .from_path_param(request.path_parameters[scoped_entity_param_key])
+            .first!
+        end
+
+        # Remembers the current scoped entity in the session.
+        #
+        # @return [void]
         def remember_scoped_entity
           return unless scoped_to_entity?
 
           session[scoped_entity_session_key] = current_scoped_entity.to_global_id.to_s
         end
 
+        # Retrieves the remembered scoped entity from the session.
+        #
+        # @return [ActiveRecord::Base, nil] the remembered scoped entity or nil if not found
+        # @raise [NotImplementedError] if not scoped to an entity
         def remembered_scoped_entity
-          ensure_legal_entity_scoping_method_access! :remembered_scoped_entity
-
-          @remembered_scoped_entity ||= GlobalID::Locator.locate session[scoped_entity_session_key]
+          ensure_legal_entity_scoping_method_access!(__method__)
+          @remembered_scoped_entity ||= GlobalID::Locator.locate(session[scoped_entity_session_key])
         end
 
+        # Ensures that the method call is legal within the current scoping context.
+        #
+        # @param method [Symbol] the method being called
+        # @raise [NotImplementedError] if not scoped to an entity
         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}"
+          raise NotImplementedError, <<~ERROR_MESSAGE
+            This request is not scoped to an entity.
+
+            Add the `scope_to_entity YourEntityRecord` directive in #{current_engine}
+            or implement #{self.class}##{method}
+          ERROR_MESSAGE
         end
       end
     end

data/lib/plutonium/pkg/app.rb

@@ -1,4 +1,4 @@
-require "active_support/notifications"
+# frozen_string_literal: true
 
 module Plutonium
   module Pkg
@@ -11,10 +11,11 @@ module Plutonium
       end
 
       class_methods do
+        include Plutonium::Concerns::ResourceValidatable
         attr_reader :scoped_entity_class, :scoped_entity_strategy, :scoped_entity_param_key
 
         def scope_to_entity(entity_class, strategy: :path, param_key: nil)
-          raise "#{entity_class} is not a valid resource record" unless entity_class.include?(Plutonium::Resource::Record)
+          validate_resource! entity_class
 
           @scoped_entity_class = entity_class
           @scoped_entity_strategy = strategy
@@ -25,122 +26,9 @@ module Plutonium
           scoped_entity_class.present?
         end
 
-        def initialize_register!
-          # this exists solely to support hot reloads
-          # if the user has modified the register especially if they removed a registration, we have no way of telling
-          # so instead we start over
-          @resource_register = []
-        end
-
-        def register_resource(resource)
-          @resource_register.append resource
-        end
-
-        def resource_register
-          @resource_register || []
-        end
-
-        def registered_resource_route_key_lookup
-          @registered_resource_route_key_lookup = resource_register.map { |resource|
-            [resource.model_name.singular_route_key.to_sym, resource]
-          }.to_h
-        end
-
-        def draw_custom_routes(&block)
-          @custom_routes_block = block
-        end
-
-        def draw_resource_routes
-          ActiveSupport::Notifications.instrument("plutonium.app.draw_resource_routes", app: self.class.module_parent.to_s) do
-            draw_resource_routes_internal
-          end
-        end
-
         def dom_id
           module_parent_name.underscore.dasherize
         end
-
-        private
-
-        def draw_resource_routes_internal
-          custom_routes_block = @custom_routes_block
-          registered_resources = resource_register
-          scoped_entity_param_key = self.scoped_entity_param_key if scoped_entity_strategy == :path
-          routes.draw do
-            shared_resource_concerns = [:interactive_resource_actions] # TODO: make this a config parameter
-            concern :interactive_resource_actions do
-              # these concerns power the interactive actions feature
-              member do
-                get "record_actions/:interactive_action", action: :begin_interactive_resource_record_action,
-                  as: :interactive_resource_record_action
-                post "record_actions/:interactive_action", action: :commit_interactive_resource_record_action
-              end
-
-              collection do
-                get "collection_actions/:interactive_action", action: :begin_interactive_resource_collection_action,
-                  as: :interactive_resource_collection_action
-                post "collection_actions/:interactive_action", action: :commit_interactive_resource_collection_action
-
-                get "recordless_actions/:interactive_action", action: :begin_interactive_resource_recordless_action,
-                  as: :interactive_resource_recordless_action
-                post "recordless_actions/:interactive_action", action: :commit_interactive_resource_recordless_action
-              end
-            end
-
-            resource_route_names = []
-            resource_route_opts_lookup = {}
-            # for each of our registered resources, we are registering the routes required
-            registered_resources.each do |resource|
-              resource_name = resource.to_s # Deeply::Namespaced::ResourceModel
-              resource_controller = resource_name.pluralize.underscore # deeply/namespaced/resource_models
-              resource_route = resource.model_name.plural # deeply_namespaced_resource_models
-              resource_route_name = :"#{resource_route}_routes" # deeply_namespaced_resource_models_routes
-
-              resource_route_opts = {}
-              # rails is not smart enough to infer Deeply::Namespaced::ResourceModelsController from deeply_namespaced_resource_models
-              # since we are heavy on namespaces, we choose to be explicit to guarantee there is no confusion
-              resource_route_opts[:controller] = resource_controller
-              # using collection for path is much nicer than the alternative
-              # e.g. deeply/namespaced/resource_models vs deeply_namespaced_resource_models
-              resource_route_opts[:path] = resource.model_name.collection
-              resource_route_opts_lookup[resource_route] = resource_route_opts
-
-              # defining our resources with concerns allows us to defer materializing till later,
-              # ensuring that resource_route_opts_lookup is populated
-              concern resource_route_name do
-                resources resource_route, **resource_route_opts, concerns: shared_resource_concerns do
-                  nested_resources_route_opts = resource_route_opts_lookup.slice(*resource.has_many_association_routes)
-                  nested_resources_route_opts.each do |nested_resource_route, nested_resource_route_opts|
-                    resources nested_resource_route, **nested_resource_route_opts, concerns: shared_resource_concerns
-                  end
-                end
-              end
-              resource_route_names << resource_route_name
-            end
-
-            # materialize our routes using a scope
-            # if the app is scoped to an entity, ensure that the expected route param and url helper prefix are specified.
-
-            # path   => /:entity/deeply/namespaced/resource_models/:deeply_namespaced_resource_model_id/
-            # helper => entity_deeply_namespaced_resource_models_path
-            scope_name = scoped_entity_param_key.present? ? ":#{scoped_entity_param_key}" : ""
-
-            # path   => /deeply/namespaced/resource_models/:deeply_namespaced_resource_model_id/
-            # helper => deeply_namespaced_resource_models_path
-            scope_options = scoped_entity_param_key.present? ? {as: scoped_entity_param_key} : {}
-
-            scope scope_name, scope_options do
-              instance_exec(&custom_routes_block) if custom_routes_block.present?
-              # we have to reverse sort our resource routes in order to prevent routing conflicts
-              # e.g. /blogs/1 and blogs/comments cause an issue if Blog is registered before Blogs::Comment
-              # attempting to load blogs/comments routes to blogs/:id which fails with a 404 since BlogsController
-              # essentially performs a Blog.find('comments')
-              # since the route names for these 2 will be 'blogs' and 'blog_comments',
-              # reverse sorting ensures that blog_comments is registered first, preventing the issue described above
-              concerns resource_route_names.sort
-            end
-          end
-        end
       end
     end
   end

data/lib/plutonium/pkg/concerns/resource_validatable.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Plutonium
+  module Pkg
+    module Concerns
+      # Provides methods for validating Plutonium resources
+      module ResourceValidatable
+        extend ActiveSupport::Concern
+
+        # Custom error class for invalid resources
+        class InvalidResourceError < StandardError; end
+
+        private
+
+        # Validates if a given resource is a valid Plutonium::Resource::Record
+        #
+        # @param resource [Object] The resource to validate
+        # @raise [InvalidResourceError] If the resource is not valid
+        # @return [void]
+        def validate_resource!(resource)
+          unless valid_resource?(resource)
+            raise InvalidResourceError, "#{resource} is not a valid Plutonium::Resource::Record"
+          end
+        end
+
+        # Checks if a given resource is a valid Plutonium::Resource::Record
+        #
+        # @param resource [Object] The resource to check
+        # @return [Boolean] True if the resource is valid, false otherwise
+        def valid_resource?(resource)
+          resource.is_a?(Class) && resource.include?(Plutonium::Resource::Record)
+        end
+      end
+    end
+  end
+end