plutonium 0.5.0

data/lib/plutonium/policy/scope.rb

@@ -0,0 +1,19 @@
+require "pundit"
+
+module Plutonium
+  module Policy
+    class Scope
+      include Plutonium::Policy::Initializer
+
+      def resolve
+        scope = context.resource_class.all
+        if @context.parent.present?
+          scope = scope.associated_with(@context.parent)
+        elsif @context.scope.present?
+          scope = scope.associated_with(@context.scope)
+        end
+        scope
+      end
+    end
+  end
+end

data/lib/plutonium/policy.rb

@@ -0,0 +1,8 @@
+module Plutonium
+  module Policy
+    extend ActiveSupport::Autoload
+
+    autoload :Initializer
+    autoload :Scope
+  end
+end

data/lib/plutonium/preserved__/field.rb

@@ -0,0 +1,65 @@
+module Plutonium
+  module UI
+    class Field
+      attr_reader :name, :label, :helper, :options
+
+      def initialize(name, **options)
+        @name = name
+        @label = options.delete :label
+        @helper = options.delete :helper
+        @options = options
+      end
+
+      def label
+        @label ||= name.to_s.titleize(keep_id_suffix: true)
+      end
+
+      def self.build(name, type:, **options)
+        options[:helper] ||= case type
+        when :string, :text, :citext
+          :display_url_value if name.ends_with? "_url"
+        when :integer, :float, :decimal
+          :display_numeric_value
+        when :datetime, :timestamp, :time, :date
+          :display_datetime_value
+        when :boolean
+          :display_boolean_value
+        when :association
+          :display_association_value
+        when :attachment
+          :display_attachment_value
+        end
+
+        # binary:      { name: "blob" },
+        # blob:        { name: "blob" },
+        # json:        { name: "json" },
+
+        options[:pu_max_width] ||= 400 if %i[string text citext].include? type
+        options[:pu_max_width] ||= 250
+
+        new name, **options
+      end
+
+      def self.for_attribute(model_class, name, type: nil, **options)
+        association = attachment = nil
+        column = model_class.column_for_attribute name if model_class.respond_to? :column_for_attribute
+        if model_class.respond_to? :reflect_on_association
+          association = model_class.reflect_on_association name
+          attachment = model_class.reflect_on_association(:"#{name}_attachment") || model_class.reflect_on_association(:"#{name}_attachments")
+        end
+
+        if attachment.present?
+          type ||= :attachment
+          options[:stack_multiple] = false if options[:stack_multiple].nil?
+        elsif association.present?
+          type ||= :association if %i[belongs_to has_one].include? association.macro
+        elsif column.present?
+          type ||= column.type
+          options[:stack_multiple] = column.array? if options[:stack_multiple].nil? && column.respond_to?(:array?)
+        end
+
+        build name, type:, **options
+      end
+    end
+  end
+end

data/lib/plutonium/preserved__/input.rb

@@ -0,0 +1,93 @@
+module Plutonium
+  module UI
+    class Input
+      attr_reader :name, :options
+
+      def initialize(name, **options)
+        @name = name
+        @options = options
+      end
+
+      def self.build(name, type:, **options)
+        multiple = options[:multiple]
+
+        definition = {}
+        case type
+        when :string, :text, :citext
+          definition = {
+            input_html: {
+              data: {controller: "textarea-autogrow"}
+            }
+          }
+        when :datetime, :timestamp, :time, :date
+          definition = {
+            html5: false
+          }
+        when :slim_select
+          definition = {
+            wrapper: :slim_select,
+            input_html: {multiple:}
+          }
+
+          if multiple
+            placeholder = options[:placeholder] || "Select #{name.to_s.humanize(capitalize: false).pluralize}"
+            definition.deep_merge! input_html: {
+              data: {
+                slim_select_placeholder_value: placeholder,
+                slim_select_close_on_select_value: false
+              }
+            }
+          else
+            placeholder = options[:placeholder] || "Select #{name.to_s.humanize(capitalize: false)}"
+            definition.deep_merge! include_blank: placeholder,
+              input_html: {
+                data: {slim_select_allow_deselect_value: true}
+              }
+          end
+        when :quill
+          definition = {wrapper: :quill}
+        when :money
+          currency = options.delete(:currency) || "$"
+          definition = {wrapper: :input_group, prepend: currency}
+        when :attachment
+          type = :file
+          definition = {
+            input_html: {multiple:},
+            attachment: true,
+            direct_upload: true
+          }
+        when :association
+          definition = {
+            as: :association
+          }
+        end
+
+        options = definition.deep_merge options
+
+        new name, **options
+      end
+
+      def self.for_attribute(model_class, name, type: nil, **options)
+        column = model_class.column_for_attribute name if model_class.respond_to? :column_for_attribute
+        if model_class.respond_to? :reflect_on_association
+          attachment = model_class.reflect_on_association(:"#{name}_attachment") || model_class.reflect_on_association(:"#{name}_attachments")
+          association = model_class.reflect_on_association(name)
+        end
+
+        type ||= :slim_select if options.key? :collection
+
+        if attachment.present?
+          type ||= :attachment
+          options[:multiple] = true if options[:multiple].nil? && attachment.macro == :has_many
+        elsif association.present?
+          type ||= :association
+        elsif column.present?
+          type ||= column.type
+          options[:multiple] = column.array? if options[:multiple].nil? && column.respond_to?(:array?)
+        end
+
+        build name, type:, **options
+      end
+    end
+  end
+end

data/lib/plutonium/reactor/core.rb

@@ -0,0 +1,61 @@
+# Be sure to restart your server when you modify this file.
+# This is a glorified initializer
+
+module Plutonium
+  module Reactor
+    class Core
+      def self.achieve_criticality!
+        Dir[Plutonium.lib_root.join("initializers", "**", "*.rb")].each do |file|
+          require file
+        end
+
+        # 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
+        )
+
+        start_reloader!
+      end
+
+      def self.start_reloader!
+        return unless Plutonium::Config.reload_files
+
+        # GLORIOUS hot reloading!!!
+        @listener ||= begin
+          require "listen"
+
+          plutonium_lib_dir = Plutonium.lib_root.to_s
+          packages_dir = Rails.root.join("packages/").to_s
+          listener = Listen.to(plutonium_lib_dir, packages_dir, only: /\.rb$/) do |modified, added, removed|
+            (modified + added).each do |file|
+              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
+                # TODO: check if guard has apis to control reloading dynamically
+                next if added.include? file
+
+                case File.basename(file)
+                when "engine.rb"
+                  # reload engines. due to how we load packages, rails does not support
+                  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
+              end
+            end
+          end
+          listener.start
+          listener
+        end
+      end
+    end
+  end
+end

data/lib/plutonium/reactor/resource_context.rb

@@ -0,0 +1,15 @@
+module Plutonium
+  module Reactor
+    class ResourceContext
+      attr_reader :user, :resource_record, :resource_class, :parent, :scope
+
+      def initialize(user:, resource_record:, resource_class:, parent: nil, scope: nil)
+        @user = user
+        @resource_record = resource_record
+        @resource_class = resource_class || resource_record&.class
+        @parent = parent
+        @scope = scope
+      end
+    end
+  end
+end

data/lib/plutonium/reactor/resource_controller.rb

@@ -0,0 +1,108 @@
+require "action_controller"
+require "pagy"
+require "ransack"
+
+require File.expand_path("refinements/parameter_refinements", Plutonium.lib_root)
+using Plutonium::Refinements::ParameterRefinements
+
+module Plutonium
+  module Reactor
+    class ResourceController < ActionController::Base
+      # remove this controller from the view lookup
+      # has the side effect of marking all public methods as private.
+      abstract!
+
+      include Pagy::Backend
+      include Plutonium::Core::Controllers::Bootable
+      include Plutonium::Core::Controllers::Authorizable
+      include Plutonium::Core::Controllers::Presentable
+
+      def self.inherited(child)
+        # Include our actions after we are inherited else they are marked as private due to our call to abstract!
+        child.send :include, Plutonium::Core::Controllers::CrudActions
+        child.send :include, Plutonium::Core::Controllers::InteractiveActions
+
+        # TODO: move this into interactive actions module
+        child.helper_method :current_interactive_action
+        super
+      end
+
+      add_flash_types :success, :warning, :error
+      append_view_path File.expand_path("app/views", Plutonium.root)
+
+      layout "resource"
+      helper Plutonium::Helpers
+
+      before_action :set_page_title
+      before_action :set_sidebar_menu
+
+      # https://github.com/ddnexus/pagy/blob/master/docs/extras/headers.md#headers
+      after_action { pagy_headers_merge(@pagy) if @pagy }
+
+      private
+
+      # def current_layout
+      #   send :_layout, lookup_context, []
+      # end
+
+      # Resource
+
+      def resource_record
+        @resource_record ||= (policy_scope(resource_class).from_path_param(params[:id]).first! if params[:id].present?)
+      end
+      helper_method :resource_record
+
+      def resource_params
+        # Example of documenting an ignore in the source code
+        # NOTE: Brakeman warning ignored for MassAssignment because inputs are filtered manually
+        input_params = params.require(resource_param_key).permit!.nilify.to_h
+
+        # 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?
+
+        current_presenter.defined_inputs_for(permitted_attributes)
+          .values.map { |input| input.collect input_params }
+          .reduce(:merge)
+      end
+
+      def resource_param_key
+        resource_class.model_name.singular_route_key
+      end
+      helper_method :resource_param_key
+
+      # Layout
+
+      def set_page_title
+        @page_title = "Pluton8"
+      end
+
+      def set_sidebar_menu
+        @sidebar_menu = build_sidebar_menu
+      end
+
+      def build_sidebar_menu
+        raise NotImplementedError, "#{self.class}#build_sidebar_menu"
+      end
+
+      def resource_context
+        Plutonium::Reactor::ResourceContext.new(
+          user: current_user,
+          resource_class:,
+          resource_record: @resource_record,
+          parent: current_parent,
+          scope: scoped_to_entity? ? current_scoped_entity : nil
+        )
+      end
+
+      ############
+
+      def current_package
+        @current_package ||= self.class.module_parents[-2]
+      end
+    end
+  end
+end

data/lib/plutonium/reactor/resource_interaction.rb

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

data/lib/plutonium/reactor/resource_policy.rb

@@ -0,0 +1,105 @@
+module Plutonium
+  module Reactor
+    class ResourcePolicy
+      include Plutonium::Policy::Initializer
+
+      class Scope < Plutonium::Policy::Scope
+      end
+
+      # Core actions
+
+      def create?
+        true
+      end
+
+      def read?
+        true
+      end
+
+      def update?
+        true
+      end
+
+      def destroy?
+        true
+      end
+
+      # Inferred actions
+
+      def index?
+        read?
+      end
+
+      def new?
+        create?
+      end
+
+      def show?
+        read?
+      end
+
+      def edit?
+        update?
+      end
+
+      # Core attributes
+
+      def permitted_attributes_for_create
+        autodetect_fields_for :permitted_attributes_for_create
+      end
+
+      def permitted_attributes_for_read
+        autodetect_fields_for :permitted_attributes_for_read
+      end
+
+      def permitted_attributes_for_update
+        permitted_attributes_for_create
+      end
+
+      # Inferred attributes
+
+      def permitted_attributes_for_index
+        permitted_attributes_for_read
+      end
+
+      def permitted_attributes_for_show
+        permitted_attributes_for_read
+      end
+
+      def permitted_attributes_for_new
+        permitted_attributes_for_create
+      end
+
+      def permitted_attributes_for_edit
+        permitted_attributes_for_update
+      end
+
+      def permitted_associations
+        []
+      end
+
+      private
+
+      def autodetect_fields_for(method_name)
+        maybe_warn_autodetect_usage method_name
+
+        context.resource_class.resource_field_names
+      end
+
+      def maybe_warn_autodetect_usage(method)
+        raise "Resource field auto-detection: #{self.class}##{method} outside development" unless Rails.env.development?
+
+        Rails.logger.warn %(
+          🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨
+
+          Resource field auto-detection: #{self.class}##{method}
+
+          Auto-detected resource fields result in security holes and will fail outside of development.
+          Override #{context.resource_class}Policy or #{self.class} with your own ##{method} method.
+
+          🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨
+        )
+      end
+    end
+  end
+end

data/lib/plutonium/reactor/resource_presenter.rb

@@ -0,0 +1,42 @@
+module Plutonium
+  module Reactor
+    class ResourcePresenter
+      include Plutonium::Core::Definers::FieldDefiner
+      include Plutonium::Core::Definers::ActionDefiner
+
+      def initialize(context)
+        @context = context
+
+        define_standard_actions
+        define_actions
+        define_fields
+      end
+
+      private
+
+      attr_reader :context
+
+      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
+
+      def resource_class = context.resource_class
+    end
+  end
+end

data/lib/plutonium/reactor/resource_record.rb

@@ -0,0 +1,123 @@
+module Plutonium
+  module Reactor
+    module ResourceRecord
+      extend ActiveSupport::Concern
+
+      included do
+        scope :from_path_param, ->(param) { where(id: param) }
+
+        scope :associated_with, ->(record) do
+          named_scope = :"associated_with_#{record.model_name.singular}"
+          return send(named_scope, record) if respond_to?(named_scope)
+
+          # TODO: add logging
+          if (own_association = reflect_on_all_associations.find { |assoc| assoc.klass == record.class })
+            case own_association.macro
+            when :has_one
+              joins(own_association.name).where({
+                own_association.name.to_sym => {
+                  record.class.primary_key => record.id
+                }
+              })
+            when :belongs_to
+              where(own_association.name => record)
+            when :has_many
+              joins(own_association.name).where(own_association.klass.table_name.to_sym => record)
+            else
+              raise Net::HTTPNotImplemented, "associated_with->##{own_association.macro}"
+            end
+          elsif (record_association = record.class.reflect_on_all_associations.find { |assoc| assoc.klass == klass })
+            # TODO: add a warning here about a potentially poor performing query
+            where(id: record.send(record_association.name))
+          else
+            raise "Could not resolve the association between '#{klass.name}' and '#{record.class.name}'\n\n" \
+                  "Define\n" \
+                  " 1. the associations between the models\n" \
+                  " 2. a named scope e.g.\n\n" \
+                  "scope :#{named_scope}, ->(#{record.model_name.singular}) { do_something_here }"
+          end
+        end
+      end
+
+      module ClassMethods
+        # Path parameters
+
+        def path_parameter(param_name)
+          param_name = param_name.to_sym
+
+          scope :from_path_param, ->(param) { where(param_name => param) }
+
+          define_method :to_param do
+            return nil unless persisted?
+
+            send param_name
+          end
+        end
+
+        def dynamic_path_parameter(param_name)
+          param_name = param_name.to_sym
+
+          scope :from_path_param, ->(param) { where(id: param.split("-").first) }
+
+          define_method :to_param do
+            return nil unless persisted?
+
+            "#{id}-#{send(param_name)}".parameterize
+          end
+        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
+
+        def ransackable_scopes(_auth_object = nil)
+          []
+        end
+
+        def resource_field_names
+          @resource_field_names ||= belongs_to_association_field_names + has_one_association_field_names +
+            has_many_association_field_names + content_column_field_names
+        end
+
+        def belongs_to_association_field_names
+          @belongs_to_association_field_names ||= reflect_on_all_associations(:belongs_to).map { |assoc| assoc.name.to_sym }
+        end
+
+        def has_one_association_field_names
+          @has_one_association_field_names ||= reflect_on_all_associations(:has_one).map { |assoc| assoc.name.to_sym }
+        end
+
+        def has_many_association_field_names
+          @has_many_association_field_names ||= reflect_on_all_associations(:has_many).map { |assoc| assoc.name.to_sym }
+        end
+
+        def content_column_field_names
+          @content_column_field_names ||= content_columns.map { |col| col.name.to_sym }
+        end
+
+        def has_many_association_routes
+          @has_many_association_routes ||= reflect_on_all_associations(:has_many).map { |assoc| assoc.klass.model_name.plural }
+        end
+      end
+
+      def to_label
+        %i[name title].each do |method|
+          name = send(method) if respond_to?(method)
+          return name if name.present?
+        end
+
+        "#{model_name.human} ##{to_param}"
+      end
+    end
+  end
+end

data/lib/plutonium/reactor.rb

@@ -0,0 +1,13 @@
+module Plutonium
+  module Reactor
+    extend ActiveSupport::Autoload
+
+    autoload :Core
+    autoload :ResourceContext
+    autoload :ResourceController
+    autoload :ResourceInteraction
+    autoload :ResourcePolicy
+    autoload :ResourcePresenter
+    autoload :ResourceRecord
+  end
+end

data/lib/plutonium/refinements/parameter_refinements.rb

@@ -0,0 +1,26 @@
+module Plutonium
+  module Refinements
+    module ParameterRefinements
+      refine ActionController::Parameters do
+        def nilify
+          transform_values { |value| nilify_internal value }
+        end
+
+        private
+
+        def nilify_internal(value)
+          case value
+          when String
+            value.presence
+          when Hash
+            nilify value
+          when Array
+            value.map { |val| nilify_internal val }.compact
+          else
+            value
+          end
+        end
+      end
+    end
+  end
+end