plutonium 0.18.5 → 0.18.6

data/lib/plutonium/resource/record/associations.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+# lib/plutonium/resource/associations.rb
+module Plutonium
+  module Resource
+    module Record
+      module Associations
+        extend ActiveSupport::Concern
+
+        class_methods do
+          def belongs_to(name, scope = nil, **options)
+            super
+            include_secure_association_methods(:belongs_to, name)
+          end
+
+          def has_one(name, scope = nil, **options)
+            super
+            include_secure_association_methods(:has_one, name)
+          end
+
+          def has_many(name, scope = nil, **options)
+            super
+            include_secure_association_methods(:has_many, name)
+          end
+
+          def has_and_belongs_to_many(name, scope = nil, **options)
+            super
+            include_secure_association_methods(:has_and_belongs_to_many, name)
+          end
+
+          private
+
+          def include_secure_association_methods(association_type, name)
+            mod = Module.new
+            mod.module_eval <<-RUBY, __FILE__, __LINE__ + 1
+              extend ActiveSupport::Concern
+
+              #{generate_sgid_methods(association_type, name)}
+
+              define_singleton_method(:to_s) { "Plutonium::Resource::Record::Associations::#{association_type.to_s.camelize}(:#{name})" }
+              define_singleton_method(:inspect) { "Plutonium::Resource::Record::Associations::#{association_type.to_s.camelize}(:#{name})" }
+            RUBY
+            include mod
+          end
+
+          def generate_sgid_methods(association_type, name)
+            case association_type
+            when :belongs_to, :has_one
+              generate_singular_sgid_methods(name)
+            when :has_many, :has_and_belongs_to_many
+              generate_collection_sgid_methods(name)
+            end
+          end
+
+          def generate_singular_sgid_methods(name)
+            <<-RUBY
+              def #{name}_sgid
+                #{name}&.to_signed_global_id
+              end
+
+              def #{name}_sgid=(sgid)
+                self.#{name} = GlobalID::Locator.locate_signed(sgid)
+              end
+            RUBY
+          end
+
+          def generate_collection_sgid_methods(name)
+            <<-RUBY
+              def #{name.to_s.singularize}_sgids
+                #{name}.map(&:to_signed_global_id)
+              end
+
+              def #{name.to_s.singularize}_sgids=(sgids)
+                self.#{name} = GlobalID::Locator.locate_many_signed(sgids)
+              end
+
+              def add_#{name.to_s.singularize}_sgid(sgid)
+                record = GlobalID::Locator.locate_signed(sgid)
+                #{name} << record if record
+              end
+
+              def remove_#{name.to_s.singularize}_sgid(sgid)
+                record = GlobalID::Locator.locate_signed(sgid)
+                #{name}.delete(record) if record
+              end
+            RUBY
+          end
+        end
+      end
+    end
+  end
+end

data/lib/plutonium/resource/record/field_names.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+# lib/plutonium/resource/associations.rb
+module Plutonium
+  module Resource
+    module Record
+      module FieldNames
+        extend ActiveSupport::Concern
+
+        class_methods do
+          def resource_field_names
+            return @resource_field_names if defined?(@resource_field_names) && !Rails.env.local?
+
+            @resource_field_names = gather_resource_field_names
+          end
+
+          def belongs_to_association_field_names
+            return @belongs_to_association_field_names if defined?(@belongs_to_association_field_names) && !Rails.env.local?
+
+            @belongs_to_association_field_names = reflect_on_all_associations(:belongs_to).map(&:name)
+          end
+
+          def has_one_association_field_names
+            return @has_one_association_field_names if defined?(@has_one_association_field_names) && !Rails.env.local?
+
+            @has_one_association_field_names = reflect_on_all_associations(:has_one)
+              .map { |assoc| (!/_attachment$|_blob$/.match?(assoc.name)) ? assoc.name : nil }
+              .compact
+          end
+
+          def has_many_association_field_names
+            return @has_many_association_field_names if defined?(@has_many_association_field_names) && !Rails.env.local?
+
+            @has_many_association_field_names = reflect_on_all_associations(:has_many)
+              .map { |assoc| (!/_attachments$|_blobs$/.match?(assoc.name)) ? assoc.name : nil }
+              .compact
+          end
+
+          def has_one_attached_field_names
+            return @has_one_attached_field_names if defined?(@has_one_attached_field_names) && !Rails.env.local?
+
+            @has_one_attached_field_names = if respond_to?(:reflect_on_all_attachments)
+              reflect_on_all_attachments
+                .select { |a| a.macro == :has_one_attached }
+                .map(&:name)
+            else
+              []
+            end
+          end
+
+          def has_many_attached_field_names
+            return @has_many_attached_field_names if defined?(@has_many_attached_field_names) && !Rails.env.local?
+
+            @has_many_attached_field_names = if respond_to?(:reflect_on_all_attachments)
+              reflect_on_all_attachments
+                .select { |a| a.macro == :has_many_attached }
+                .map(&:name)
+            else
+              []
+            end
+          end
+
+          def content_column_field_names
+            return @content_column_field_names if defined?(@content_column_field_names) && !Rails.env.local?
+
+            @content_column_field_names = content_columns.map { |col| col.name.to_sym }
+          end
+
+          private
+
+          def gather_resource_field_names
+            belongs_to_association_field_names +
+              has_one_attached_field_names +
+              has_one_association_field_names +
+              has_many_attached_field_names +
+              has_many_association_field_names +
+              content_column_field_names
+          end
+        end
+      end
+    end
+  end
+end

data/lib/plutonium/resource/record/labeling.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+# lib/plutonium/resource/associations.rb
+module Plutonium
+  module Resource
+    module Record
+      module Labeling
+        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
+end

data/lib/plutonium/resource/record/routes.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+# lib/plutonium/resource/associations.rb
+module Plutonium
+  module Resource
+    module Record
+      module Routes
+        extend ActiveSupport::Concern
+
+        included do
+          scope :from_path_param, ->(param) { where(id: param) }
+        end
+
+        class_methods do
+          def has_many_association_routes
+            return @has_many_association_routes if defined?(@has_many_association_routes) && !Rails.env.local?
+
+            @has_many_association_routes = reflect_on_all_associations(:has_many).map { |assoc| assoc.klass.model_name.plural }
+          end
+
+          def all_nested_attributes_options
+            unless Rails.env.local?
+              return @all_nested_attributes_options if defined?(@all_nested_attributes_options)
+            end
+
+            @all_nested_attributes_options = reflect_on_all_associations.map do |association|
+              setter_method = "#{association.name}_attributes="
+              if method_defined?(setter_method)
+                [association.name, nested_attributes_options[association.name].merge(
+                  macro: association.macro,
+                  class: association.polymorphic? ? nil : association.klass
+                )]
+              end
+            end.compact.to_h
+          end
+
+          private
+
+          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
+        end
+      end
+    end
+  end
+end

data/lib/plutonium/resource/record.rb

@@ -2,265 +2,13 @@ module Plutonium
   module Resource
     module Record
       extend ActiveSupport::Concern
-      include Plutonium::Models::HasCents
-
-      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 support for polymorphic associations
-          # TODO: add logging
-          # TODO: memoize this
-
-          own_association = klass.find_association_from_self_to_record(record)
-          if own_association
-            return klass.query_based_on_association(own_association, record)
-          end
-
-          record_association = klass.find_association_to_self_from_record(record)
-          if record_association
-            # TODO: add a warning here about a potentially poor performing query
-            return where(id: record.public_send(record_association.name))
-          end
-
-          klass.raise_association_error(record, named_scope)
-        end
-      end
-
-      class_methods do
-        # Returns the resource field names
-        # @return [Array<Symbol>]
-        def resource_field_names
-          return @resource_field_names if defined?(@resource_field_names) && !Rails.env.local?
-
-          @resource_field_names = gather_resource_field_names
-        end
-
-        # Overrides belongs_to to add support for polymorphic associations
-        # @param [Symbol] name The name of the association
-        # @param [Proc] scope The scope for the association
-        # @param [Hash] options The options for the association
-        def belongs_to(name, scope = nil, **options)
-          super
-
-          return unless 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::Polymorphic::BelongsTo(:#{name})" }
-            define_singleton_method(:inspect) { "Plutonium::Polymorphic::BelongsTo(:#{name})" }
-          RUBY
-          include mod
-        end
-
-        # Returns the names of belongs_to associations
-        # @return [Array<Symbol>]
-        def belongs_to_association_field_names
-          return @belongs_to_association_field_names if defined?(@belongs_to_association_field_names) && !Rails.env.local?
-
-          @belongs_to_association_field_names = reflect_on_all_associations(:belongs_to).map(&:name)
-        end
-
-        # Returns the names of has_one associations
-        # @return [Array<Symbol>]
-        def has_one_association_field_names
-          return @has_one_association_field_names if defined?(@has_one_association_field_names) && !Rails.env.local?
-
-          @has_one_association_field_names = reflect_on_all_associations(:has_one)
-            .map { |assoc| (!/_attachment$|_blob$/.match?(assoc.name)) ? assoc.name : nil }
-            .compact
-        end
-
-        # Returns the names of has_many associations
-        # @return [Array<Symbol>]
-        def has_many_association_field_names
-          return @has_many_association_field_names if defined?(@has_many_association_field_names) && !Rails.env.local?
-
-          @has_many_association_field_names = reflect_on_all_associations(:has_many)
-            .map { |assoc| (!/_attachments$|_blobs$/.match?(assoc.name)) ? assoc.name : nil }
-            .compact
-        end
-
-        # Returns the names of has_one attached associations
-        # @return [Array<Symbol>]
-        def has_one_attached_field_names
-          return @has_one_attached_field_names if defined?(@has_one_attached_field_names) && !Rails.env.local?
-
-          @has_one_attached_field_names = if respond_to?(:reflect_on_all_attachments)
-            reflect_on_all_attachments
-              .select { |a| a.macro == :has_one_attached }
-              .map(&:name)
-          else
-            []
-          end
-        end
-
-        # Returns the names of has_many attached associations
-        # @return [Array<Symbol>]
-        def has_many_attached_field_names
-          return @has_many_attached_field_names if defined?(@has_many_attached_field_names) && !Rails.env.local?
 
-          @has_many_attached_field_names = if respond_to?(:reflect_on_all_attachments)
-            reflect_on_all_attachments
-              .select { |a| a.macro == :has_many_attached }
-              .map(&:name)
-          else
-            []
-          end
-        end
-
-        # Returns the names of content columns
-        # @return [Array<Symbol>]
-        def content_column_field_names
-          return @content_column_field_names if defined?(@content_column_field_names) && !Rails.env.local?
-
-          @content_column_field_names = content_columns.map { |col| col.name.to_sym }
-        end
-
-        # Returns the routes for has_many associations
-        # @return [Array<Symbol>]
-        def has_many_association_routes
-          return @has_many_association_routes if defined?(@has_many_association_routes) && !Rails.env.local?
-
-          @has_many_association_routes = reflect_on_all_associations(:has_many).map { |assoc| assoc.klass.model_name.plural }
-        end
-
-        # Returns all nested attributes options
-        # @return [Hash]
-        def all_nested_attributes_options
-          unless Rails.env.local?
-            return @all_nested_attributes_options if defined?(@all_nested_attributes_options)
-          end
-
-          @all_nested_attributes_options = reflect_on_all_associations.map do |association|
-            setter_method = "#{association.name}_attributes="
-            if method_defined?(setter_method)
-              [association.name, nested_attributes_options[association.name].merge(
-                macro: association.macro,
-                class: association.polymorphic? ? nil : association.klass
-              )]
-            end
-          end.compact.to_h
-        end
-
-        # Finds the association to the given record
-        # @param [ActiveRecord::Base] record The record to find the association with
-        # @return [ActiveRecord::Reflection::AssociationReflection, nil]
-        def find_association_from_self_to_record(record)
-          reflect_on_all_associations.find do |assoc|
-            assoc.klass.name == record.class.name unless assoc.polymorphic?
-          rescue
-            assoc.check_validity!
-            raise
-          end
-        end
-
-        # Finds the association to self in the given record
-        # @param [ActiveRecord::Base] record The record to find the association with
-        # @return [ActiveRecord::Reflection::AssociationReflection, nil]
-        def find_association_to_self_from_record(record)
-          record.class.reflect_on_all_associations.find do |assoc|
-            assoc.klass.name == name
-          rescue
-            assoc.check_validity!
-            raise
-          end
-        end
-
-        # Queries based on the association type
-        # @param [ActiveRecord::Reflection::AssociationReflection] assoc The association
-        # @param [ActiveRecord::Base] record The record to query with
-        # @return [ActiveRecord::Relation]
-        def query_based_on_association(assoc, record)
-          case assoc.macro
-          when :has_one
-            joins(assoc.name).where(assoc.name => {record.class.primary_key => record.id})
-          when :belongs_to
-            where(assoc.name => record)
-          when :has_many
-            joins(assoc.name).where(assoc.klass.table_name => record)
-          else
-            raise NotImplementedError, "associated_with->##{assoc.macro}"
-          end
-        end
-
-        # Raises an error for unresolved associations
-        # @param [ActiveRecord::Base] record The record with unresolved association
-        # @param [Symbol] named_scope The named scope
-        # @raise [RuntimeError]
-        def raise_association_error(record, named_scope)
-          raise "Could not resolve the association between '#{name}' and '#{record.class.name}'\n\n" \
-                "Define\n" \
-                " 1. the associations between the models\n" \
-                " 2. a named scope on #{name} e.g.\n\n" \
-                "scope :#{named_scope}, ->(#{record.model_name.singular}) { do_something_here }"
-        end
-
-        private
-
-        # Defines a scope and method for path parameters
-        # @param [Symbol] param_name The name of the parameter
-        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
-
-        # Defines a scope and method for dynamic path parameters
-        # @param [Symbol] param_name The name of the parameter
-        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
-
-        # Gathers all resource field names
-        # @return [Array<Symbol>]
-        def gather_resource_field_names
-          belongs_to_association_field_names +
-            has_one_attached_field_names +
-            has_one_association_field_names +
-            has_many_attached_field_names +
-            has_many_association_field_names +
-            content_column_field_names
-        end
-      end
-
-      # Returns a label for the record
-      # @return [String]
-      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
+      include Plutonium::Models::HasCents
+      include Plutonium::Resource::Record::Routes
+      include Plutonium::Resource::Record::Labeling
+      include Plutonium::Resource::Record::FieldNames
+      include Plutonium::Resource::Record::Associations
+      include Plutonium::Resource::Record::AssociatedWith
     end
   end
 end

data/lib/plutonium/ui/breadcrumbs.rb

@@ -87,7 +87,7 @@ module Plutonium
             end
 
             # Record
-            if resource_record.present?
+            if resource_record?
               # Record Resource
               li(class: "flex items-center") do
                 svg(
@@ -112,7 +112,7 @@ module Plutonium
               end
 
               # Record Itself
-              if resource_record.persisted? && action_name != "show"
+              if resource_record!.persisted? && action_name != "show"
                 li(class: "flex items-center") do
                   svg(
                     class: "rtl:rotate-180 block w-3 h-3 mx-1 text-gray-400",
@@ -129,8 +129,8 @@ module Plutonium
                       d: "m1 9 4-4-4-4"
                     )
                   end
-                  link_to display_name_of(resource_record),
-                    resource_url_for(resource_record),
+                  link_to display_name_of(resource_record!),
+                    resource_url_for(resource_record!),
                     class:
                       "ms-1 text-sm font-medium text-gray-700 hover:text-primary-600 md:ms-2 dark:text-gray-200 dark:hover:text-white"
                 end

data/lib/plutonium/ui/component/methods.rb

@@ -10,18 +10,6 @@ module Plutonium
 
         private
 
-        def resource_class
-          helpers.controller.send(:resource_class)
-        end
-
-        def resource_record
-          helpers.controller.send(:resource_record)
-        end
-
-        def current_parent
-          helpers.controller.send(:current_parent)
-        end
-
         def params
           helpers.controller.params
         end
@@ -35,11 +23,15 @@ module Plutonium
         end
 
         delegate \
+          :resource_class,
+          :resource_record!,
+          :resource_record?,
           :resource_name,
           :resource_name_plural,
           :display_name_of,
           :resource_url_for,
           :current_user,
+          :current_parent,
           :current_definition,
           :current_query_object,
           :raw_resource_query_params,

data/lib/plutonium/ui/form/base.rb

@@ -19,16 +19,6 @@ module Plutonium
             select_tag(**attributes, class!: "", &)
           end
 
-          def belongs_to_tag(**attributes, &)
-            attributes[:data_controller] = tokens(attributes[:data_controller], "slim-select") # TODO: put this behind a config
-            create_component(Components::BelongsTo, :belongs_to, **attributes, &)
-          end
-
-          def has_many_tag(**attributes, &)
-            attributes[:data_controller] = tokens(attributes[:data_controller], "slim-select") # TODO: put this behind a config
-            create_component(Components::HasMany, :has_many, **attributes, &)
-          end
-
           def flatpickr_tag(**, &)
             create_component(Components::Flatpickr, :flatpickr, **, &)
           end
@@ -42,6 +32,28 @@ module Plutonium
             create_component(Components::Uppy, :uppy, **, &)
           end
           alias_method :file_tag, :uppy_tag
+
+          def secure_association_tag(**attributes, &)
+            attributes[:data_controller] = tokens(attributes[:data_controller], "slim-select") # TODO: put this behind a config
+            create_component(Components::SecureAssociation, :association, **attributes, &)
+          end
+          # preserve original methods with prefix
+          alias_method :basic_belongs_to_tag, :belongs_to_tag
+          alias_method :basic_has_many_tag, :has_many_tag
+          alias_method :basic_has_one_tag, :has_one_tag
+          # use new methods as defaults
+          alias_method :belongs_to_tag, :secure_association_tag
+          alias_method :has_many_tag, :secure_association_tag
+          alias_method :has_one_tag, :secure_association_tag
+
+          def secure_polymorphic_association_tag(**attributes, &)
+            attributes[:data_controller] = tokens(attributes[:data_controller], "slim-select") # TODO: put this behind a config
+            create_component(Components::SecurePolymorphicAssociation, :polymorphic_association, **attributes, &)
+          end
+          # preserve original methods with prefix
+          alias_method :basic_polymorphic_belongs_to_tag, :polymorphic_belongs_to_tag
+          # use new methods as defaults
+          alias_method :polymorphic_belongs_to_tag, :secure_polymorphic_association_tag
         end
 
         private