plutonium 0.10.1 → 0.10.2

data/lib/plutonium/resource/record.rb

@@ -10,113 +10,135 @@ module Plutonium
           named_scope = :"associated_with_#{record.model_name.singular}"
           return send(named_scope, record) if respond_to?(named_scope)
 
-          # TODO: add suppport for polymorphic associations
+          # TODO: add support for polymorphic associations
           # TODO: add logging
           # TODO: memoize this
 
-          if (own_association = reflect_on_all_associations.find { |assoc| assoc.klass.name == record.class.name })
-            case own_association.macro
-            when :has_one
-              joins(own_association.name).where({
-                own_association.name => {
-                  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 => record)
-            else
-              raise NotImplementedError, "associated_with->##{own_association.macro}"
-            end
-          elsif (record_association = record.class.reflect_on_all_associations.find { |assoc| assoc.klass.name == klass.name })
+          own_association = klass.find_association_to_record(record)
+          if own_association
+            return klass.query_based_on_association(own_association, record)
+          end
+
+          record_association = klass.find_association_to_self(record)
+          if record_association
             # 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 on #{klass.name} e.g.\n\n" \
-                  "scope :#{named_scope}, ->(#{record.model_name.singular}) { do_something_here }"
+            return where(id: record.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
-          @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
+          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(name, scope, **options)
 
-          if options[:polymorphic]
-            mod = Module.new
-            mod.module_eval <<-RUBY, __FILE__, __LINE__ + 1
-              extend ActiveSupport::Concern
+          return unless options[:polymorphic]
 
-              def #{name}_sgid
-                #{name}&.to_signed_global_id
-              end
+          mod = Module.new
+          mod.module_eval <<-RUBY, __FILE__, __LINE__ + 1
+            extend ActiveSupport::Concern
 
-              def #{name}_sgid=(sgid)
-                self.#{name} = GlobalID::Locator.locate_signed(sgid)
-              end
+            def #{name}_sgid
+              #{name}&.to_signed_global_id
+            end
 
-              define_singleton_method(:to_s) { "Plutonium::Polymormorphic::BelongsTo(:#{name})" }
-              define_singleton_method(:inspect) { "Plutonium::Polymormorphic::BelongsTo(:#{name})" }
-            RUBY
-            include mod
-          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
-          @belongs_to_association_field_names ||= reflect_on_all_associations(:belongs_to).map(&:name)
+          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
-          @has_one_association_field_names ||= reflect_on_all_associations(:has_one)
-            .map { |assoc| /_attachment$|_blob$/.match?(assoc.name) ? nil : assoc.name }
+          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
-          @has_many_association_field_names ||= reflect_on_all_associations(:has_many)
-            .map { |assoc| /_attachments$|_blobs$/.match?(assoc.name) ? nil : assoc.name }
+          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
-          @has_one_attached_field_names ||= if respond_to?(:reflect_on_all_attachments)
+          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
-              .map { |a| (a.macro == :has_one_attached) ? a.name : nil }
-              .compact
+              .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
-          @has_many_attached_field_names ||= if respond_to?(:reflect_on_all_attachments)
+          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
-              .map { |a| (a.macro == :has_many_attached) ? a.name : nil }
-              .compact
+              .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
-          @content_column_field_names ||= content_columns.map { |col| col.name.to_sym }
+          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
-          @has_many_association_routes ||= reflect_on_all_associations(:has_many).map { |assoc| assoc.klass.model_name.plural }
+          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)
@@ -125,98 +147,155 @@ module Plutonium
           @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],
+              [association.name, nested_attributes_options[association.name].merge(
                 macro: association.macro,
                 class: association.polymorphic? ? nil : association.klass
-              }]
+              )]
             end
           end.compact.to_h
         end
 
-        #
         # Returns the strong parameters definition for the given attribute names
-        #
-        # @param [Array] *attributes Attribute names
-        #
-        # @return [Array] A strong parameters compatible array e.g.
-        #   [:title, :body, {:images=>[]}, {:docs=>[]}]
-        #
+        # @param [Array<Symbol>] *attributes Attribute names
+        # @return [Array<Symbol, Hash>] A strong parameters compatible array
         def strong_parameters_for(*attributes)
-          # attributes that are passed but we do not have a model/database backed definition for e.g. virtual attributes.
-          # if they are passed and we are not expecting them, our inputs will filter them out as they apply an additional level
-          # of filtering
           unbacked = attributes - strong_parameters_definition.keys
 
-          # attributes backed by some model/database definition
-          # {:name=>{:name=>nil}, :body=>{:body=>nil}, :cover_image=>{:cover_image=>nil}, :comments=>{:comment_ids=>[]}}
-          backed = strong_parameters_definition.
-            # {:name=>{:name=>nil}, :comments=>{:comment_ids=>[]}, :cover_image=>{:cover_image=>nil}}
-            slice(*attributes).
-            # [{:name=>nil}, {:comment_ids=>[]}, {:cover_image=>nil}]
-            values.
-            # {:name=>nil, :comment_ids=>[], :cover_image=>nil}
-            reduce(:merge)&.
-            # [:name, {:comment_ids=>[]}, :cover_image]
-            map { |key, value| value.nil? ? key : {key => value} } || {}
+          backed = strong_parameters_definition.slice(*attributes).values.reduce(:merge)
+            &.map { |key, value| value.nil? ? key : {key => value} } || {}
 
-          unbacked + backed
+          case backed.presence
+          when Hash
+            [*unbacked, **backed]
+          when Array
+            [*unbacked, *backed]
+          when nil
+            unbacked
+          else
+            raise "Unexpected strong parameters definition: #{backed.class}"
+          end
+        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_to_record(record)
+          reflect_on_all_associations.find do |assoc|
+            assoc.klass.name == record.class.name
+          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(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 the strong parameters
+        # @return [Hash]
         def strong_parameters_definition
           unless Rails.env.local?
             return @strong_parameters if defined?(@strong_parameters)
           end
 
-          @strong_parameters = begin
-            # Columns
-
-            content_column_parameters = content_column_field_names.map do |name|
-              column = columns_hash[name.to_s]
-
-              type = nil
-              type = [] if column&.try(:array?)
-              type = {} if [:json, :jsonb].include?(column&.type)
+          @strong_parameters = build_strong_parameters
+        end
 
-              [name, {name => type}]
+        # Builds the strong parameters hash
+        # @return [Hash]
+        def build_strong_parameters
+          parameters = content_column_field_names.map do |name|
+            column = columns_hash[name.to_s]
+            type = if column.try(:array?)
+              []
+            else
+              ([:json, :jsonb].include?(column&.type) ? {} : nil)
             end
-            parameters = content_column_parameters.to_h
+            [name, {name => type}]
+          end.to_h
 
-            # Associations
+          parameters.merge!(belongs_to_association_parameters)
+          parameters.merge!(has_many_association_parameters)
+          parameters.merge!(attachment_parameters)
+          parameters.merge!(nested_attributes_parameters)
 
-            parameters.merge! reflect_on_all_associations(:belongs_to)
-              .map { |reflection|
-                                input_param = reflection.respond_to?(:options) ? reflection.options[:foreign_key] : :"#{reflection.name}_id"
-                                [reflection.name, {input_param => nil}]
-                              }
-              .to_h
-
-            parameters.merge! has_many_association_field_names
-              .map { |name| [name, {"#{name.to_s.singularize}_ids": []}] }
-              .to_h
-
-            # Attachments
-
-            parameters.merge! has_many_attached_field_names.map { |name| [name, {name => []}] }.to_h
-
-            parameters.merge! has_one_attached_field_names.map { |name| [name, {name => nil}] }.to_h
+          parameters
+        end
 
-            # Nested Attributes
+        # Returns the parameters for belongs_to associations
+        # @return [Hash]
+        def belongs_to_association_parameters
+          reflect_on_all_associations(:belongs_to).map do |reflection|
+            input_param = reflection.options[:foreign_key] || :"#{reflection.name}_id"
+            [reflection.name, {input_param => nil}]
+          end.to_h
+        end
 
-            parameters.merge! all_nested_attributes_options.keys
-              .map { |name| [name, {"#{name}_attributes" => {}}] }
-              .to_h
+        # Returns the parameters for has_many associations
+        # @return [Hash]
+        def has_many_association_parameters
+          has_many_association_field_names.map do |name|
+            [name, {"#{name.to_s.singularize}_ids": []}]
+          end.to_h
+        end
 
-            # e.g.
-            # {:name=>{:name=>nil}, :cover_image=>{:cover_image=>nil}, :user=>{:user_id=>nil} :comments=>{:comment_ids=>[]}}
-            parameters
-          end
+        # Returns the parameters for attachments
+        # @return [Hash]
+        def attachment_parameters
+          has_many_attached_field_names.map { |name| [name, {name => []}] }.to_h
+            .merge(has_one_attached_field_names.map { |name| [name, {name => nil}] }.to_h)
         end
 
-        # Path parameters
+        # Returns the parameters for nested attributes
+        # @return [Hash]
+        def nested_attributes_parameters
+          all_nested_attributes_options.keys.map do |name|
+            [name, {"#{name}_attributes" => {}}]
+          end.to_h
+        end
 
+        # 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
 
@@ -225,10 +304,12 @@ module Plutonium
           define_method :to_param do
             return nil unless persisted?
 
-            send param_name
+            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
 
@@ -240,8 +321,21 @@ module Plutonium
             "#{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)

data/lib/plutonium/rodauth/controller_methods.rb

@@ -6,6 +6,13 @@ module Plutonium
       included do
         layout "rodauth"
         append_view_path File.expand_path("app/views", Plutonium.root)
+        helper_method :application_name
+      end
+
+      private
+
+      def application_name
+        Rails.application.class.module_parent.name
       end
     end
   end

data/lib/plutonium/version.rb

@@ -1,3 +1,3 @@
 module Plutonium
-  VERSION = "0.10.1"
+  VERSION = "0.10.2"
 end

data/lib/plutonium.rb

@@ -19,33 +19,71 @@ module Plutonium
     root.join("lib", "plutonium")
   end
 
+  def self.logger
+    Rails.logger
+  end
+
+  def self.development?
+    ActiveModel::Type::Boolean.new.cast(ENV["PLUTONIUM_DEV"]).present?
+  end
+
   def self.stylesheet_link
-    if Plutonium::Config.development
+    return @stylesheet_link if defined?(@stylesheet_link) && !development?
+
+    if development?
       base_dir = "/plutonium-assets/build"
-      manifest = "css.dev.manifest"
       filename = "plutonium-dev.css"
     else
       base_dir = "/plutonium-assets"
-      manifest = "css.manifest"
       filename = "plutonium.css"
     end
 
-    file = JSON.parse(File.read(root.join(manifest)))[filename]
-    "#{base_dir}/#{file}"
+    file = stylesheet_manifest[filename]
+    @stylesheet_link = "#{base_dir}/#{file}"
   end
 
   def self.script_link
+    return @script_link if defined?(@script_link) && !development?
+
     filename = "plutonium-app.js"
-    if Plutonium::Config.development
-      base_dir = "/plutonium-assets/build"
-      manifest = "js.dev.manifest"
+    base_dir = if development?
+      "/plutonium-assets/build"
     else
-      base_dir = "/plutonium-assets"
-      manifest = "js.manifest"
+      "/plutonium-assets"
+    end
+
+    file = script_manifest[filename]
+    @script_link = "#{base_dir}/#{file}"
+  end
+
+  def self.favicon_link
+    "/plutonium-assets/plutonium.ico"
+  end
+
+  def self.logo_link
+    "/plutonium-assets/plutonium-logo.png"
+  end
+
+  def self.stylesheet_manifest
+    return @stylesheet_manifest if defined?(@stylesheet_manifest) && !development?
+
+    manifest = if development?
+      "css.dev.manifest"
+    else
+      "css.manifest"
     end
+    @stylesheet_manifest = JSON.parse(File.read(root.join(manifest)))
+  end
+
+  def self.script_manifest
+    return @script_manifest if defined?(@script_manifest) && !development?
 
-    file = JSON.parse(File.read(root.join(manifest)))[filename]
-    "#{base_dir}/#{file}"
+    manifest = if development?
+      "js.dev.manifest"
+    else
+      "js.manifest"
+    end
+    @script_manifest = JSON.parse(File.read(root.join(manifest)))
   end
 end