plutonium 0.6.2 → 0.9.0

data/lib/plutonium/preserved__/{field.rb → field.rb.bk}

@@ -1,5 +1,5 @@
 module Plutonium
-  module UI
+  module Ui
     class Field
       attr_reader :name, :label, :helper, :options
 

data/lib/plutonium/preserved__/{input.rb → input.rb.bk}

@@ -1,5 +1,5 @@
 module Plutonium
-  module UI
+  module Ui
     class Input
       attr_reader :name, :options
 

data/lib/plutonium/railtie.rb

@@ -1,10 +1,24 @@
-# frozen_string_literal: true
+require "view_component"
 
 module Plutonium
   class Railtie < Rails::Railtie
-    # add railties here
+    initializer "plutonium.assets_server" do
+      # setup a middleware to serve our assets
+      config.app_middleware.insert_before(
+        ActionDispatch::Static,
+        Rack::Static,
+        urls: ["/plutonium-assets"],
+        root: Plutonium.root.join("public"),
+        cascade: true,
+        header_rules: [
+          # Cache all static files in public caches (e.g. Rack::Cache) as well as in the browser
+          [:all, {"cache-control" => "public, max-age=31536000"}]
+        ]
+      )
+    end
 
-    initializer "plutonium.achieve_criticality" do
+    initializer "plutonium.view_components" do
+      config.view_component.capture_compatibility_patch_enabled = true
     end
   end
 end

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,11 +1,17 @@
 module Plutonium
-  module Reactor
-    class ResourcePolicy
+  module Resource
+    class Policy
       include Plutonium::Policy::Initializer
 
       class Scope < Plutonium::Policy::Scope
       end
 
+      def send_with_report(method)
+        raise NotImplementedError, "#{self.class.name} does not implement the required #{method}" unless respond_to? method
+
+        send method
+      end
+
       # Core actions
 
       def create?
@@ -42,10 +48,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/resource/presenter.rb

@@ -0,0 +1,78 @@
+module Plutonium
+  module Resource
+    class Presenter
+      include Plutonium::Core::Definers::FieldDefiner
+      include Plutonium::Core::Definers::ActionDefiner
+
+      def initialize(context, resource_record)
+        @context = context
+        @resource_record = resource_record
+
+        define_standard_actions
+        define_actions
+        define_fields
+      end
+
+      private
+
+      attr_reader :context, :resource_record
+
+      def define_fields
+        # override this in child presenters for custom field definitions
+      end
+
+      def define_actions
+        # override this in child presenters for custom action definitions
+      end
+
+      def define_standard_actions
+        define_action Plutonium::Core::Actions::NewAction.new(:new)
+        define_action Plutonium::Core::Actions::ShowAction.new(:show)
+        define_action Plutonium::Core::Actions::EditAction.new(:edit)
+        define_action Plutonium::Core::Actions::DestroyAction.new(:destroy)
+      end
+
+      # TODO: move this to its own definer
+      def define_interactive_action(name, interaction:, **)
+        define_action Plutonium::Core::Actions::InteractiveAction.new(name, interaction:, **)
+      end
+
+      # TODO: move this to its own definer
+      def define_nested_input(name, inputs:, model_class: nil, **options)
+        nested_attribute_options = resource_class.all_nested_attributes_options[name]
+
+        nested_attribute_options_class = nested_attribute_options&.[](:class)
+        if nested_attribute_options_class.nil? && model_class.nil?
+          raise ArgumentError, "model_class is required if your field is not an association or is polymorphic"
+        end
+        model_class ||= nested_attribute_options_class
+
+        macro = nested_attribute_options&.[](:macro)
+        allow_destroy = nested_attribute_options&.[](:allow_destroy).presence
+        update_only = nested_attribute_options&.[](:update_only).presence
+        limit = if macro == :has_one
+          1
+        elsif options.key?(:limit)
+          options[:limit]
+        else
+          nested_attribute_options&.[](:limit)
+        end
+
+        input = Plutonium::Core::Fields::Inputs::NestedInput.new(
+          name,
+          inputs:,
+          allow_destroy: options.key?(:allow_destroy) ? options[:allow_destroy] : allow_destroy,
+          update_only: options.key?(:update_only) ? options[:update_only] : update_only,
+          limit: limit,
+          resource_class: model_class,
+          **options
+        )
+        yield input if block_given?
+
+        define_input name, input:
+      end
+
+      def resource_class = context.resource_class
+    end
+  end
+end

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