plutonium 0.6.2 → 0.8.0

data/lib/plutonium/reactor/core.rb

@@ -5,33 +5,42 @@ module Plutonium
   module Reactor
     class Core
       def self.achieve_criticality!
-        Dir[Plutonium.lib_root.join("initializers", "**", "*.rb")].each do |file|
-          require file
-        end
+        # Eager load the framework
+        # Plutonium::ZEITWERK_LOADER.eager_load
+
+        # Load view components
+        load Plutonium.root.join("app", "views", "components", "base.rb")
 
-        # setup a middleware to serve our assets
-        Rails.application.config.middleware.insert_before(
-          ActionDispatch::Static,
-          Rack::Static,
-          urls: ["/plutonium-assets"],
-          root: Plutonium.root.join("public"),
-          cascade: true
-        )
+        # Load initializers
+        Dir.glob(Plutonium.root.join("config", "initializers", "**", "*.rb")) { |file| load file }
 
         start_reloader!
       end
 
       def self.start_reloader!
-        return unless Plutonium::Config.reload_files
+        # TODO: see which parts of this can be moved into zeitwerk
+        return unless Plutonium::Config.enable_hotreload
 
-        # GLORIOUS hot reloading!!!
+        # GLORIOUS hotreload!!!
         @listener ||= begin
           require "listen"
 
-          plutonium_lib_dir = Plutonium.lib_root.to_s
+          reload_paths = []
+
+          if Plutonium::Config.development
+            reload_paths << Plutonium.lib_root.to_s
+            reload_paths << Plutonium.root.join("app", "views", "components").to_s
+            reload_paths << Plutonium.root.join("config", "initializers").to_s
+          end
+
+          # we want to always watch packages for changes to engines
           packages_dir = Rails.root.join("packages/").to_s
-          listener = Listen.to(plutonium_lib_dir, packages_dir, only: /\.rb$/) do |modified, added, removed|
+          reload_paths << packages_dir if File.directory?(packages_dir)
+
+          listener = Listen.to(*reload_paths, only: /\.rb$/) do |modified, added, removed|
             (modified + added).each do |file|
+              next if file == __FILE__ # reloading this file does nothing
+
               if file.starts_with?(packages_dir)
                 # if package file was added, ignore it
                 # otherwise rails gets mad at us since engines cannot be loaded after initial boot
@@ -40,18 +49,24 @@ module Plutonium
 
                 case File.basename(file)
                 when "engine.rb"
-                  # reload engines. due to how we load packages, rails does not support
+                  # rails engines are loaded once,
+                  # so in order to detect resource registration changes, we need to handle reloads ourselves
+
+                  # load the engine and reload routes to pick up any registration changes
+                  Rails.logger.debug "\nplutonium: reloaded #{file}\n"
                   load file
-                  # reload routes to pick up any registration changes
                   Rails.application.reload_routes!
                 else
                   # non engine package files are reloaded by rails automatically
                 end
               else
-                load file
+                Plutonium::ZEITWERK_LOADER.reload
+                load Plutonium.root.join("app", "views", "components", "base.rb")
+                load file # this just a lazy way to ensure we load files that do not contain constants like initializers
               end
+              Rails.logger.debug "\n\nplutonium: reload #{file}\n"
             rescue => e
-              Rails.logger.error "\npu.hotreloader: failed to reload #{file}\n\n#{e}\n"
+              Rails.logger.error "\n\nplutonium: reload failed #{file}\n\n#{e}\n"
             end
           end
           listener.start

data/lib/plutonium/refinements/parameter_refinements.rb

@@ -1,3 +1,5 @@
+require "action_controller"
+
 module Plutonium
   module Refinements
     module ParameterRefinements

data/lib/plutonium/resource/context.rb

@@ -0,0 +1,5 @@
+module Plutonium
+  module Resource
+    Context = Data.define :resource_class, :parent, :scope
+  end
+end

data/lib/plutonium/resource/controller.rb

@@ -0,0 +1,138 @@
+require "action_controller"
+require "pagy"
+
+require File.expand_path("refinements/parameter_refinements", Plutonium.lib_root)
+using Plutonium::Refinements::ParameterRefinements
+
+module Plutonium
+  module Resource
+    module Controller
+      extend ActiveSupport::Concern
+      include Pagy::Backend
+      include Plutonium::Core::Controllers::Base
+      include Plutonium::Core::Controllers::Authorizable
+      include Plutonium::Core::Controllers::Presentable
+      include Plutonium::Core::Controllers::Queryable
+      include Plutonium::Core::Controllers::CrudActions
+      include Plutonium::Core::Controllers::InteractiveActions
+
+      included do
+        # we use class attribute since we want this value inherited
+        class_attribute :resource_class, instance_writer: false, instance_predicate: false
+
+        # https://github.com/ddnexus/pagy/blob/master/docs/extras/headers.md#headers
+        after_action { pagy_headers_merge(@pagy) if @pagy }
+
+        helper_method :current_parent, :resource_record, :resource_param_key, :resource_class
+      end
+
+      class_methods do
+        def controller_for(resource_class)
+          self.resource_class = resource_class
+        end
+      end
+
+      private
+
+      def policy_context
+        Plutonium::Resource::PolicyContext.new(
+          user: current_user,
+          resource_context: resource_context
+        )
+      end
+
+      def resource_record
+        @resource_record ||= (policy_scope(resource_class).from_path_param(params[:id]).first! if params[:id].present?)
+      end
+
+      def submitted_resource_params
+        @submitted_resource_params ||= begin
+          strong_parameters = resource_class.strong_parameters_for(*permitted_attributes)
+          params.require(resource_param_key).permit(*strong_parameters).nilify.to_h
+        end
+      end
+
+      def resource_params
+        input_params = submitted_resource_params.dup
+
+        # Override any entity scoping params
+        input_params[scoped_entity_param_key] = current_scoped_entity if scoped_to_entity?
+        input_params[:"#{scoped_entity_param_key}_id"] = current_scoped_entity.id if scoped_to_entity?
+        # Override any parent params
+        input_params[parent_input_param] = current_parent if current_parent.present?
+        input_params[:"#{parent_input_param}_id"] = current_parent.id if current_parent.present?
+
+        # additionally filter our input_params through our inputs
+        current_presenter.defined_inputs_for(*permitted_attributes).collect_all(input_params)
+      end
+
+      def resource_param_key
+        resource_class.model_name.singular_route_key
+      end
+
+      def resource_context
+        Plutonium::Resource::Context.new(
+          resource_class:,
+          parent: current_parent,
+          scope: scoped_to_entity? ? current_scoped_entity : nil
+        )
+      end
+
+      def resource_presenter(resource_class, resource_record)
+        presenter_class = "#{current_package}::#{resource_class}Presenter".constantize
+        presenter_class.new resource_context, resource_record
+      end
+
+      def resource_query_object(resource_class, params)
+        query_object_class = "#{current_package}::#{resource_class}QueryObject".constantize
+        query_object_class.new resource_context, params
+      end
+
+      # sets params on submitted_resource_params if they have been passed
+      def maybe_apply_submitted_resource_params!
+        # this is useful in dynamic forms as we can read the resource record to determine how to define our inputs
+        # we need to ensure that this is being called from get because
+        # it is potentially unsafe since we don't apply the input filter. see #resource_params
+        # would have been nice to be able to, but we can't until we have the presenter, and the presenter
+        # requires the resource_record for our dynamic forms
+        # is this perfect? no. but it works.
+        raise "🚨🚨🚨 this should be called from actions that are not persisting this data" unless request.method == "GET"
+
+        resource_record.attributes = submitted_resource_params if params[resource_param_key].present?
+      end
+
+      def current_parent
+        return unless parent_route_param.present?
+
+        @current_parent ||= begin
+          parent_route_key = parent_route_param.to_s.gsub(/_id$/, "").to_sym
+          parent_class = current_engine.registered_resource_route_key_lookup[parent_route_key]
+          parent_scope = parent_class.from_path_param(params[parent_route_param])
+          parent_scope = parent_scope.associated_with(current_scoped_entity) if scoped_to_entity?
+          parent_scope.first!
+        end
+      end
+
+      def parent_route_param
+        @parent_route_param ||= request.path_parameters.keys.reverse.find { |key| /_id$/.match? key }
+      end
+
+      def parent_input_param
+        return unless current_parent.present?
+
+        resource_class.reflect_on_all_associations(:belongs_to).find { |assoc| assoc.klass.name == current_parent.class.name }&.name&.to_sym
+      end
+
+      ############
+
+      # def current_package
+      #   @current_package ||= self.class.module_parents[-2]
+      # end
+
+      def resource_url_args_for(*args, **kwargs)
+        kwargs[:parent] = current_parent unless kwargs.key?(:parent)
+        super(*args, **kwargs)
+      end
+    end
+  end
+end

data/lib/plutonium/resource/interaction.rb

@@ -0,0 +1,8 @@
+require "active_interaction"
+
+module Plutonium
+  module Resource
+    class Interaction < ActiveInteraction::Base
+    end
+  end
+end

data/lib/plutonium/{reactor/resource_policy.rb → resource/policy.rb}

@@ -1,6 +1,6 @@
 module Plutonium
-  module Reactor
-    class ResourcePolicy
+  module Resource
+    class Policy
       include Plutonium::Policy::Initializer
 
       class Scope < Plutonium::Policy::Scope
@@ -42,10 +42,17 @@ module Plutonium
         update?
       end
 
+      def search?
+        index?
+      end
+
       # Core attributes
 
       def permitted_attributes_for_create
-        autodetect_fields_for(:permitted_attributes_for_create) - [context.resource_context.resource_class.primary_key.to_sym, :created_at, :updated_at]
+        autodetect_fields_for(:permitted_attributes_for_create) - [
+          context.resource_context.resource_class.primary_key.to_sym, # primary_key
+          :created_at, :updated_at # timestamps
+        ]
       end
 
       def permitted_attributes_for_read

data/lib/plutonium/{reactor → resource}/policy_context.rb

@@ -1,5 +1,5 @@
 module Plutonium
-  module Reactor
+  module Resource
     PolicyContext = Data.define :user, :resource_context
   end
 end

data/lib/plutonium/{reactor/resource_presenter.rb → resource/presenter.rb}

@@ -1,6 +1,6 @@
 module Plutonium
-  module Reactor
-    class ResourcePresenter
+  module Resource
+    class Presenter
       include Plutonium::Core::Definers::FieldDefiner
       include Plutonium::Core::Definers::ActionDefiner
 
@@ -13,10 +13,6 @@ module Plutonium
         define_fields
       end
 
-      def search_field
-        nil
-      end
-
       private
 
       attr_reader :context, :resource_record

data/lib/plutonium/resource/query_object.rb

@@ -0,0 +1,219 @@
+# TODO: refactor
+
+module Plutonium
+  # TODO: make standard query type names e.g. search and scope configurable
+  module Resource
+    class QueryObject
+      class << self
+      end
+
+      class Query
+        include Plutonium::Core::Definers::InputDefiner
+
+        def apply(scope, params)
+          params = extract_query_params params
+
+          if input_definitions.size == params.size
+            apply_internal scope, params
+          else
+            scope
+          end
+        end
+
+        private
+
+        def apply_internal(scope, params)
+          raise NotImplementedError, "#{self.class}#apply_internal"
+        end
+
+        def extract_query_params(params)
+          input_definitions.collect_all(params).symbolize_keys
+        end
+
+        def resource_class = nil
+      end
+
+      class ScopeQuery < Query
+        attr_reader :name
+
+        def initialize(name)
+          @name = name
+          yield self if block_given?
+        end
+
+        private
+
+        def apply_internal(scope, params)
+          scope.send name, **params
+        end
+      end
+
+      class BlockQuery < Query
+        attr_reader :body
+
+        def initialize(body)
+          @body = body
+          yield self if block_given?
+        end
+
+        def apply_internal(scope, params)
+          if body.arity == 1
+            body.call scope
+          else
+            body.call scope, **params
+          end
+        end
+      end
+
+      attr_reader :search_filter, :search_query
+
+      def initialize(context, params)
+        @context = context
+
+        define_standard_queries
+        define_scopes
+        define_filters
+        define_sorters
+
+        extract_filter_params(params)
+        extract_sort_params(params)
+        # @params = params.except(:scope, :search, :sort_fields, :sort_directions)
+      end
+
+      def build_url(**options)
+        q = {}
+
+        q[:search] = options.key?(:search) ? options[:search].presence : search_query
+        q[:scope] = options.key?(:scope) ? options[:scope].presence : selected_scope_filter
+
+        q[:sort_directions] = selected_sort_directions.dup
+        q[:sort_fields] = selected_sort_fields.dup
+        if (sort = options[:sort])
+          if options[:reset]
+            q[:sort_fields].delete_if { |e| e == sort.to_s }
+            q[:sort_directions].delete sort
+          else
+            q[:sort_fields] << sort.to_s unless q[:sort_fields].include?(sort.to_s)
+
+            sort_direction = selected_sort_directions[sort]
+            if sort_direction.nil?
+              q[:sort_directions][sort] = "ASC"
+            elsif sort_direction == "ASC"
+              q[:sort_directions][sort] = "DESC"
+            else
+              q[:sort_fields].delete_if { |e| e == sort.to_s }
+              q[:sort_directions].delete sort
+            end
+          end
+        end
+
+        "?#{{q: q}.to_param}"
+      end
+
+      def apply(scope)
+        scope = search_filter.apply(scope, {search: search_query}) if search_filter.present?
+        scope = scope_definitions[selected_scope_filter].apply(scope, {}) if selected_scope_filter.present?
+        selected_sort_fields.each do |name|
+          sorter = sort_definitions[name]
+          next unless sorter.present?
+
+          params = {direction: selected_sort_directions[name] || "ASC"}
+          scope = sorter.apply(scope, params)
+        end
+        scope
+      end
+
+      def scope_definitions = @scope_definitions ||= {}.with_indifferent_access
+
+      def filter_definitions = @filter_definitions ||= {}.with_indifferent_access
+
+      def sort_definitions = @sort_definitions ||= {}.with_indifferent_access
+
+      def sort_params_for(name)
+        return unless sort_definitions[name]
+
+        {
+          url: build_url(sort: name),
+          reset_url: build_url(sort: name, reset: true),
+          position: selected_sort_fields.index(name.to_s),
+          direction: selected_sort_directions[name]
+        }
+      end
+
+      private
+
+      attr_reader :context, :selected_sort_fields, :selected_sort_directions, :selected_scope_filter
+
+      def define_filters
+      end
+
+      def define_scopes
+      end
+
+      def define_sorters
+      end
+
+      def define_standard_queries
+        define_search(:search) if resource_class.respond_to?(:search)
+      end
+
+      def define_filter(name, body = nil, &)
+        body ||= name
+        filter_definitions[name] = build_query(body, &)
+      end
+
+      def define_scope(name, body = nil)
+        body ||= name
+        scope_definitions[name] = build_query(body)
+      end
+
+      def define_sort(name, body = nil)
+        if body.nil?
+          sort_field = if resource_class.primary_key == name.to_s || resource_class.content_column_field_names.include?(name)
+            name
+          elsif resource_class.belongs_to_association_field_names.include? name
+            resource_class.reflect_on_association(name).foreign_key.to_sym
+          else
+            raise "Unable to determine sort logic for '#{body}'"
+          end
+          body = lambda { |scope, direction:| scope.order(sort_field => direction) }
+        end
+
+        sort_definitions[name] = build_query(body) do |query|
+          query.define_input :direction
+        end
+      end
+
+      def define_search(body)
+        @search_filter = build_query(body) do |query|
+          query.define_input :search
+        end
+      end
+
+      def extract_filter_params(params)
+        @search_query = params[:search]
+        @selected_scope_filter = params[:scope]
+      end
+
+      def extract_sort_params(params)
+        @selected_sort_fields = Array(params[:sort_fields])
+        @selected_sort_fields &= sort_definitions.keys
+
+        @selected_sort_directions = params[:sort_directions]&.slice(*sort_definitions.keys) || {}
+        @selected_sort_directions = @selected_sort_directions.map { |key, value| [key, {"DESC" => "DESC"}[value.upcase] || "ASC"] }.to_h.with_indifferent_access
+      end
+
+      def build_query(body, &)
+        case body
+        when Symbol
+          raise "Cannot find scope :#{body} on #{resource_class}" unless resource_class.respond_to? body
+          ScopeQuery.new(body, &)
+        else
+          BlockQuery.new(body, &)
+        end
+      end
+
+      def resource_class = context.resource_class
+    end
+  end
+end

data/lib/plutonium/{reactor/resource_record.rb → resource/record.rb}

@@ -1,6 +1,6 @@
 module Plutonium
-  module Reactor
-    module ResourceRecord
+  module Resource
+    module Record
       extend ActiveSupport::Concern
 
       included do
@@ -10,10 +10,11 @@ module Plutonium
           named_scope = :"associated_with_#{record.model_name.singular}"
           return send(named_scope, record) if respond_to?(named_scope)
 
-          # TOD: add suppport for polymorphic associations
-
+          # TODO: add suppport for polymorphic associations
           # TODO: add logging
-          if (own_association = reflect_on_all_associations.find { |assoc| assoc.klass == record.class })
+          # TODO: memoize this
+
+          if (own_association = reflect_on_all_associations.find { |assoc| assoc.klass.name == record.class.name })
             case own_association.macro
             when :has_one
               joins(own_association.name).where({
@@ -28,7 +29,7 @@ module Plutonium
             else
               raise NotImplementedError, "associated_with->##{own_association.macro}"
             end
-          elsif (record_association = record.class.reflect_on_all_associations.find { |assoc| assoc.klass == klass })
+          elsif (record_association = record.class.reflect_on_all_associations.find { |assoc| assoc.klass.name == klass.name })
             # TODO: add a warning here about a potentially poor performing query
             where(id: record.send(record_association.name))
           else
@@ -41,7 +42,7 @@ module Plutonium
         end
       end
 
-      module ClassMethods
+      class_methods do
         def resource_field_names
           @resource_field_names ||= belongs_to_association_field_names +
             has_one_attached_field_names + has_one_association_field_names +
@@ -49,6 +50,29 @@ module Plutonium
             content_column_field_names
         end
 
+        def belongs_to(name, scope = nil, **options)
+          super(name, scope, **options)
+
+          if options[:polymorphic]
+            mod = Module.new
+            mod.module_eval <<-RUBY, __FILE__, __LINE__ + 1
+              extend ActiveSupport::Concern
+
+              def #{name}_sgid
+                #{name}&.to_signed_global_id
+              end
+
+              def #{name}_sgid=(sgid)
+                self.#{name} = GlobalID::Locator.locate_signed(sgid)
+              end
+
+              define_singleton_method(:to_s) { "Plutonium::Polymormorphic::BelongsTo(:#{name})" }
+              define_singleton_method(:inspect) { "Plutonium::Polymormorphic::BelongsTo(:#{name})" }
+            RUBY
+            include mod
+          end
+        end
+
         def belongs_to_association_field_names
           @belongs_to_association_field_names ||= reflect_on_all_associations(:belongs_to).map(&:name)
         end
@@ -66,15 +90,23 @@ module Plutonium
         end
 
         def has_one_attached_field_names
-          @has_one_attached_field_names ||= reflect_on_all_attachments
-            .map { |a| (a.macro == :has_one_attached) ? a.name : nil }
-            .compact
+          @has_one_attached_field_names ||= if respond_to?(:reflect_on_all_attachments)
+            reflect_on_all_attachments
+              .map { |a| (a.macro == :has_one_attached) ? a.name : nil }
+              .compact
+          else
+            []
+          end
         end
 
         def has_many_attached_field_names
-          @has_many_attached_field_names ||= reflect_on_all_attachments
-            .map { |a| (a.macro == :has_many_attached) ? a.name : nil }
-            .compact
+          @has_many_attached_field_names ||= if respond_to?(:reflect_on_all_attachments)
+            reflect_on_all_attachments
+              .map { |a| (a.macro == :has_many_attached) ? a.name : nil }
+              .compact
+          else
+            []
+          end
         end
 
         def content_column_field_names
@@ -94,34 +126,22 @@ module Plutonium
         #   [:title, :body, {:images=>[]}, {:docs=>[]}]
         #
         def strong_parameters_for(*attributes)
+          # attributes that are passed but we do not have a model/database backed definition for e.g. virtual attributes.
+          unbacked = attributes - strong_parameters_definition.keys
+
+          # attributes backed by some model/database definition
           # {:name=>{:name=>nil}, :body=>{:body=>nil}, :cover_image=>{:cover_image=>nil}, :comments=>{:comment_ids=>[]}}
-          strong_parameters_definition
+          backed = strong_parameters_definition.
             # {:name=>{:name=>nil}, :comments=>{:comment_ids=>[]}, :cover_image=>{:cover_image=>nil}}
-            .slice(*attributes)
+            slice(*attributes).
             # [{:name=>nil}, {:comment_ids=>[]}, {:cover_image=>nil}]
-            .values
+            values.
             # {:name=>nil, :comment_ids=>[], :cover_image=>nil}
-            .reduce(:merge)
+            reduce(:merge)&.
             # [:name, {:comment_ids=>[]}, :cover_image]
-            &.map { |key, value| value.nil? ? key : {key => value} } || {}
-        end
-
-        # Ransack
-
-        def ransackable_attributes(_auth_object = nil)
-          _ransackers.keys
-        end
-
-        def ransackable_associations(_auth_object = nil)
-          [] # reflect_on_all_associations.map { |a| a.name.to_s }
-        end
-
-        def ransortable_attributes(auth_object = nil)
-          ransackable_attributes(auth_object) + %w[id created_at updated_at]
-        end
+            map { |key, value| value.nil? ? key : {key => value} } || {}
 
-        def ransackable_scopes(_auth_object = nil)
-          []
+          unbacked + backed
         end
 
         private

data/lib/plutonium/rodauth/controller_methods.rb

@@ -0,0 +1,12 @@
+module Plutonium
+  module Rodauth
+    module ControllerMethods
+      extend ActiveSupport::Concern
+
+      included do
+        layout "rodauth"
+        append_view_path File.expand_path("app/views", Plutonium.root)
+      end
+    end
+  end
+end

data/lib/plutonium/{simple_form_components → simple_form}/attachment_component.rb

@@ -1,3 +1,5 @@
+require "simple_form"
+
 module Plutonium
   module SimpleForm
     module AttachmentComponent