plutonium 0.18.4 → 0.18.6

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

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+# lib/plutonium/resource/associations.rb
+module Plutonium
+  module Resource
+    module Record
+      module AssociatedWith
+        extend ActiveSupport::Concern
+
+        included do
+          scope :associated_with, ->(record) do
+            named_scope = :"associated_with_#{record.model_name.singular}"
+            return send(named_scope, record) if respond_to?(named_scope)
+
+            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
+              Plutonium.logger.warn do
+                [
+                  "Using indirect association from #{record.class} to #{klass.name}",
+                  "via '#{record_association.name}'.",
+                  "This may result in poor query performance for large datasets",
+                  "as it requires loading records to perform the association.",
+                  "",
+                  "Consider defining a direct association or implementing",
+                  "a custom scope '#{named_scope}' for better performance."
+                ].join("\n")
+              end
+              return where(id: record.public_send(record_association.name))
+            end
+
+            klass.raise_unresolvable_association_error(record, named_scope)
+          end
+        end
+
+        class_methods do
+          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
+
+          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
+
+          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
+
+          def raise_unresolvable_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
+        end
+      end
+    end
+  end
+end

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/routing/mapper_extensions.rb

@@ -19,7 +19,7 @@ module Plutonium
       # @yield An optional block for additional resource configuration.
       # @return [void]
       def register_resource(resource, options = {}, &)
-        route_config = route_set.register_resource(resource, &)
+        route_config = route_set.register_resource(resource, options, &)
         define_resource_routes(route_config, resource)
         resource_route_concern_names << route_config[:concern_name]
       end
@@ -65,7 +65,7 @@ module Plutonium
       # @return [void]
       def define_resource_routes(route_config, resource)
         concern route_config[:concern_name] do
-          resources route_config[:route_name], **route_config[:route_options] do
+          send route_config[:route_type], route_config[:route_name], **route_config[:route_options] do
             instance_exec(&route_config[:block]) if route_config[:block]
             define_nested_resource_routes(resource)
           end

data/lib/plutonium/routing/route_set_extensions.rb

@@ -49,17 +49,18 @@ module Plutonium
       # Registers a resource for routing.
       #
       # @param resource [Class] The resource class to be registered.
+      # @param options [Hash] Additional options for resource registration.
       # @yield An optional block for additional resource configuration.
       # @return [Hash] The configuration for the registered resource.
       # @raise [ArgumentError] If the engine is not supported.
-      def register_resource(resource, &)
+      def register_resource(resource, options = {}, &)
         self.class.validate_engine! engine
         engine.resource_register.register(resource)
 
         route_name = resource.model_name.plural
         concern_name = :"#{route_name}_routes"
 
-        config = create_resource_config(resource, route_name, concern_name, &)
+        config = create_resource_config(resource, route_name, concern_name, options, &)
         resource_route_config_lookup[route_name] = config
 
         config
@@ -101,15 +102,17 @@ module Plutonium
       # @param resource_name [String] The name of the resource.
       # @param route_name [String] The pluralized name for routes.
       # @param concern_name [Symbol] The name of the concern for this resource.
+      # @param options [Hash] Additional options for resource registration.
       # @yield An optional block for additional resource configuration.
       # @return [Hash] The complete resource configuration.
-      def create_resource_config(resource, route_name, concern_name, &block)
+      def create_resource_config(resource, route_name, concern_name, options = {}, &block)
         {
+          route_type: options[:singular] ? :resource : :resources,
           route_name: route_name,
           concern_name: concern_name,
           route_options: {
             controller: resource.to_s.pluralize.underscore,
-            path: resource.model_name.collection,
+            path: options[:singular] ? resource.model_name.singular : resource.model_name.collection,
             concerns: %i[interactive_resource_actions]
           },
           block: block