plutonium 0.10.2 → 0.11.0

data/lib/plutonium/resource/query_object.rb

@@ -1,61 +1,57 @@
-# TODO: make standard query type names e.g. search and scope configurable
-
 module Plutonium
   module Resource
-    # The QueryObject class is responsible for handling various query types and applying them to the given scope.
     class QueryObject
       class << self
       end
 
-      # The Query class serves as a base for different types of queries.
       class Query
         include Plutonium::Core::Definers::InputDefiner
 
-        # Applies the query to the given scope with the provided parameters.
+        # Applies the query to the given scope using the provided parameters.
         #
-        # @param scope [Object] the scope to apply the query on
-        # @param params [Hash] the parameters for the query
-        # @return [Object] the modified scope
+        # @param scope [Object] The initial scope to which the query will be applied.
+        # @param params [Hash] The parameters for the query.
+        # @return [Object] The modified scope.
         def apply(scope, params)
           params = extract_query_params(params)
-          (input_definitions.size == params.size) ? apply_internal(scope, params) : scope
+
+          if input_definitions.size == params.size
+            apply_internal(scope, params)
+          else
+            scope
+          end
         end
 
         private
 
-        # Raises an error, should be implemented by subclasses.
+        # Abstract method to apply the query logic to the scope.
+        # Should be implemented by subclasses.
         #
-        # @param scope [Object] the scope to apply the query on
-        # @param params [Hash] the parameters for the query
-        # @raise [NotImplementedError] if not implemented by subclass
+        # @param scope [Object] The initial scope.
+        # @param params [Hash] The parameters for the query.
+        # @raise [NotImplementedError] If the method is not implemented.
         def apply_internal(scope, params)
           raise NotImplementedError, "#{self.class}#apply_internal"
         end
 
-        # Extracts and processes query parameters.
+        # Extracts query parameters based on the defined inputs.
         #
-        # @param params [Hash] the parameters to process
-        # @return [Hash] the processed parameters
+        # @param params [Hash] The parameters to extract.
+        # @return [Hash] The extracted and symbolized parameters.
         def extract_query_params(params)
           input_definitions.collect_all(params).compact.symbolize_keys
         end
 
-        # Returns the resource class, to be implemented by subclasses.
-        #
-        # @return [Class, nil] the resource class
-        def resource_class
-          nil
-        end
+        # @return [nil] The resource class (default implementation returns nil).
+        def resource_class = nil
       end
 
-      # The ScopeQuery class represents a query based on a scope.
       class ScopeQuery < Query
         attr_reader :name
 
-        # Initializes a ScopeQuery.
+        # Initializes a ScopeQuery with a given name.
         #
-        # @param name [Symbol] the name of the scope
-        # @yield [self] optional block to configure the query
+        # @param name [Symbol] The name of the scope.
         def initialize(name)
           @name = name
           yield self if block_given?
@@ -63,24 +59,22 @@ module Plutonium
 
         private
 
-        # Applies the scope query to the given scope with the provided parameters.
+        # Applies the scope query to the given scope.
         #
-        # @param scope [Object] the scope to apply the query on
-        # @param params [Hash] the parameters for the query
-        # @return [Object] the modified scope
+        # @param scope [Object] The initial scope.
+        # @param params [Hash] The parameters for the query.
+        # @return [Object] The modified scope.
         def apply_internal(scope, params)
           scope.send(name, **params)
         end
       end
 
-      # The BlockQuery class represents a query based on a block.
       class BlockQuery < Query
         attr_reader :body
 
-        # Initializes a BlockQuery.
+        # Initializes a BlockQuery with a given block of code.
         #
-        # @param body [Proc] the block to apply
-        # @yield [self] optional block to configure the query
+        # @param body [Proc] The block of code for the query.
         def initialize(body)
           @body = body
           yield self if block_given?
@@ -88,22 +82,26 @@ module Plutonium
 
         private
 
-        # Applies the block query to the given scope with the provided parameters.
+        # Applies the block query to the given scope.
         #
-        # @param scope [Object] the scope to apply the query on
-        # @param params [Hash] the parameters for the query
-        # @return [Object] the modified scope
+        # @param scope [Object] The initial scope.
+        # @param params [Hash] The parameters for the query.
+        # @return [Object] The modified scope.
         def apply_internal(scope, params)
-          (body.arity == 1) ? body.call(scope) : body.call(scope, **params)
+          if body.arity == 1
+            body.call(scope)
+          else
+            body.call(scope, **params)
+          end
         end
       end
 
-      attr_reader :search_filter, :search_query, :context, :selected_sort_fields, :selected_sort_directions, :selected_scope_filter
+      attr_reader :search_filter, :search_query
 
-      # Initializes a QueryObject.
+      # Initializes a QueryObject with the given context and parameters.
       #
-      # @param context [Object] the context in which the queries are defined
-      # @param params [Hash] the initial parameters for the query object
+      # @param context [Object] The context in which the query object is used.
+      # @param params [Hash] The parameters for initialization.
       def initialize(context, params)
         @context = context
 
@@ -116,59 +114,43 @@ module Plutonium
         extract_sort_params(params)
       end
 
-      # Builds a URL with the current query parameters.
+      # Builds a URL with the given options for search and sorting.
       #
-      # @param options [Hash] additional options for building the URL
-      # @return [String] the built URL
+      # @param options [Hash] The options for building the URL.
+      # @return [String] The constructed URL with query parameters.
       def build_url(**options)
         q = {}
-        q[:search] = options.fetch(:search, search_query).presence
-        q[:scope] = options.fetch(:scope, selected_scope_filter).presence
+
+        q[:search] = options.key?(:search) ? options[:search].presence : search_query
+        q[:scope] = options.key?(:scope) ? options[:scope].presence : selected_scope_filter
+
         q[:sort_directions] = selected_sort_directions.dup
         q[:sort_fields] = selected_sort_fields.dup
-
-        if (sort = options[:sort])
-          handle_sort_options(q, sort, options[:reset])
-        end
+        handle_sort_options!(q, options)
 
         "?#{{q: q}.to_param}"
       end
 
-      # Applies the queries to the given scope.
+      # Applies the defined filters and sorts to the given scope.
       #
-      # @param scope [Object] the scope to apply the queries on
-      # @return [Object] the modified scope
+      # @param scope [Object] The initial scope to which filters and sorts are applied.
+      # @return [Object] The modified scope.
       def apply(scope)
         scope = search_filter.apply(scope, {search: search_query}) if search_filter.present?
         scope = scope_definitions[selected_scope_filter].apply(scope, {}) if selected_scope_filter.present?
-        apply_sorters(scope)
+        apply_sorts(scope)
       end
 
-      # Retrieves the scope definitions.
-      #
-      # @return [HashWithIndifferentAccess] the scope definitions
-      def scope_definitions
-        @scope_definitions ||= {}.with_indifferent_access
-      end
+      def scope_definitions = @scope_definitions ||= {}.with_indifferent_access
 
-      # Retrieves the filter definitions.
-      #
-      # @return [HashWithIndifferentAccess] the filter definitions
-      def filter_definitions
-        @filter_definitions ||= {}.with_indifferent_access
-      end
+      def filter_definitions = @filter_definitions ||= {}.with_indifferent_access
 
-      # Retrieves the sort definitions.
-      #
-      # @return [HashWithIndifferentAccess] the sort definitions
-      def sort_definitions
-        @sort_definitions ||= {}.with_indifferent_access
-      end
+      def sort_definitions = @sort_definitions ||= {}.with_indifferent_access
 
-      # Retrieves the sort parameters for a given name.
+      # Provides sorting parameters for the given field name.
       #
-      # @param name [Symbol] the name of the sort field
-      # @return [Hash, nil] the sort parameters or nil if not defined
+      # @param name [Symbol, String] The name of the field to sort.
+      # @return [Hash, nil] The sorting parameters including URL and direction.
       def sort_params_for(name)
         return unless sort_definitions[name]
 
@@ -182,59 +164,64 @@ module Plutonium
 
       private
 
-      # Placeholder method for defining filters.
+      attr_reader :context, :selected_sort_fields, :selected_sort_directions, :selected_scope_filter
+
+      # Defines standard filters.
       def define_filters
+        # Implement filter definitions if needed
       end
 
-      # Placeholder method for defining scopes.
+      # Defines standard scopes.
       def define_scopes
+        # Implement scope definitions if needed
       end
 
-      # Placeholder method for defining sorters.
+      # Defines standard sorters.
       def define_sorters
+        # Implement sorter definitions if needed
       end
 
-      # Defines standard queries.
+      # Defines standard queries for search and scope.
       def define_standard_queries
         define_search(:search) if resource_class.respond_to?(:search)
       end
 
-      # Defines a filter.
+      # Defines a filter with the given name and body.
       #
-      # @param name [Symbol] the name of the filter
-      # @param body [Proc, nil] the body of the filter
-      # @yield [Query] optional block to configure the query
+      # @param name [Symbol] The name of the filter.
+      # @param body [Proc, nil] The body of the filter.
       def define_filter(name, body = nil, &block)
         body ||= name
         filter_definitions[name] = build_query(body, &block)
       end
 
-      # Defines a scope.
+      # Defines a scope with the given name and body.
       #
-      # @param name [Symbol] the name of the scope
-      # @param body [Proc, nil] the body of the scope
+      # @param name [Symbol] The name of the scope.
+      # @param body [Proc, nil] The body of the scope.
       def define_scope(name, body = nil)
         body ||= name
         scope_definitions[name] = build_query(body)
       end
 
-      # Defines a sort.
+      # Defines a sort with the given name and body.
       #
-      # @param name [Symbol] the name of the sort field
-      # @param body [Proc, nil] the body of the sort
-      def define_sort(name, body = nil)
+      # @param name [Symbol] The name of the sort.
+      # @param body [Proc, nil] The body of the sort.
+      def define_sorter(name, body = nil)
         if body.nil?
           sort_field = determine_sort_field(name)
           body = ->(scope, direction:) { scope.order(sort_field => direction) }
         end
+
         sort_definitions[name] = build_query(body) do |query|
           query.define_input :direction
         end
       end
 
-      # Defines a search filter.
+      # Defines a search filter with the given body.
       #
-      # @param body [Proc] the body of the search filter
+      # @param body [Proc, Symbol] The body of the search filter.
       def define_search(body)
         @search_filter = build_query(body) do |query|
           query.define_input :search
@@ -243,7 +230,7 @@ module Plutonium
 
       # Extracts filter parameters from the given params.
       #
-      # @param params [Hash] the parameters to extract from
+      # @param params [Hash] The parameters to extract.
       def extract_filter_params(params)
         @search_query = params[:search]
         @selected_scope_filter = params[:scope]
@@ -251,39 +238,35 @@ module Plutonium
 
       # Extracts sort parameters from the given params.
       #
-      # @param params [Hash] the parameters to extract from
+      # @param params [Hash] The parameters to extract.
       def extract_sort_params(params)
-        @selected_sort_fields = Array(params[:sort_fields]) & sort_definitions.keys
-        @selected_sort_directions = (params[:sort_directions]&.slice(*sort_definitions.keys) || {}).transform_values { |v| (v.upcase == "DESC") ? "DESC" : "ASC" }.with_indifferent_access
+        @selected_sort_fields = Array(params[:sort_fields])
+        @selected_sort_fields &= sort_definitions.keys
+
+        @selected_sort_directions = extract_sort_directions(params)
       end
 
-      # Builds a query object.
+      # Builds a query object based on the given body and optional block.
       #
-      # @param body [Symbol, Proc] the body of the query
-      # @yield [Query] optional block to configure the query
-      # @return [Query] the built query object
+      # @param body [Proc, Symbol] The body of the query.
+      # @yieldparam query [Query] The query object.
+      # @return [Query] The constructed query object.
       def build_query(body, &block)
         case body
         when Symbol
           raise "Cannot find scope :#{body} on #{resource_class}" unless resource_class.respond_to?(body)
+
           ScopeQuery.new(body, &block)
         else
           BlockQuery.new(body, &block)
         end
       end
 
-      # Retrieves the resource class.
+      # Determines the sort field for the given name.
       #
-      # @return [Class] the resource class
-      def resource_class
-        context.resource_class
-      end
-
-      # Determines the sort field for a given name.
-      #
-      # @param name [Symbol] the name of the sort field
-      # @return [Symbol] the determined sort field
-      # @raise [RuntimeError] if unable to determine sort logic for the field
+      # @param name [Symbol, String] The name of the field.
+      # @return [Symbol] The sort field.
+      # @raise [RuntimeError] If unable to determine sort logic.
       def determine_sort_field(name)
         if resource_class.primary_key == name.to_s || resource_class.content_column_field_names.include?(name)
           name
@@ -294,39 +277,65 @@ module Plutonium
         end
       end
 
-      # Handles sorting options.
+      # Extracts sort directions from the given params.
+      #
+      # @param params [Hash] The parameters to extract.
+      # @return [Hash] The extracted sort directions.
+      def extract_sort_directions(params)
+        params[:sort_directions]&.slice(*sort_definitions.keys) || {}
+      end
+
+      # Handles the sort options for building the URL.
+      #
+      # @param query_params [Hash] The query parameters.
+      # @param options [Hash] The options for sorting.
+      def handle_sort_options!(query_params, options)
+        if (sort = options[:sort])
+          handle_sort_reset!(query_params, sort, options[:reset])
+        end
+      end
+
+      # Handles the reset option for sorting.
       #
-      # @param query [Hash] the query parameters
-      # @param sort [Symbol] the sort field
-      # @param reset [Boolean] whether to reset the sorting
-      def handle_sort_options(query, sort, reset)
+      # @param query_params [Hash] The query parameters.
+      # @param sort [Symbol, String] The sort field.
+      # @param reset [Boolean] Whether to reset the sort.
+      def handle_sort_reset!(query_params, sort, reset)
         if reset
-          query[:sort_fields].delete_if { |e| e == sort.to_s }
-          query[:sort_directions].delete(sort)
+          query_params[:sort_fields].delete_if { |e| e == sort.to_s }
+          query_params[:sort_directions].delete(sort)
         else
-          query[:sort_fields] << sort.to_s unless query[:sort_fields].include?(sort.to_s)
+          query_params[:sort_fields] << sort.to_s unless query_params[:sort_fields].include?(sort.to_s)
+
           sort_direction = selected_sort_directions[sort]
-          query[:sort_directions][sort] = if sort_direction.nil?
-            "ASC"
+          if sort_direction.nil?
+            query_params[:sort_directions][sort] = "ASC"
+          elsif sort_direction == "ASC"
+            query_params[:sort_directions][sort] = "DESC"
           else
-            ((sort_direction == "ASC") ? "DESC" : "ASC")
+            query_params[:sort_fields].delete_if { |e| e == sort.to_s }
+            query_params[:sort_directions].delete(sort)
           end
-          query[:sort_fields].delete_if { |e| e == sort.to_s } if query[:sort_directions][sort] == "ASC"
         end
       end
 
-      # Applies sorters to the scope.
+      # Applies the defined sorters to the given scope.
       #
-      # @param scope [Object] the scope to apply sorters on
-      # @return [Object] the modified scope
-      def apply_sorters(scope)
+      # @param scope [Object] The initial scope.
+      # @return [Object] The modified scope.
+      def apply_sorts(scope)
         selected_sort_fields.each do |name|
           sorter = sort_definitions[name]
           next unless sorter.present?
-          scope = sorter.apply(scope, {direction: selected_sort_directions[name] || "ASC"})
+
+          params = {direction: selected_sort_directions[name] || "ASC"}
+          scope = sorter.apply(scope, params)
         end
         scope
       end
+
+      # @return [Object] The resource class from the context.
+      def resource_class = context.resource_class
     end
   end
 end

data/lib/plutonium/rodauth/controller_methods.rb

@@ -4,15 +4,19 @@ module Plutonium
       extend ActiveSupport::Concern
 
       included do
+        helper Plutonium::Helpers::ApplicationHelper
+        helper Plutonium::Helpers::ComponentHelper
+        helper Plutonium::Helpers::AssetsHelper
+
         layout "rodauth"
         append_view_path File.expand_path("app/views", Plutonium.root)
-        helper_method :application_name
+        helper_method :root_path
       end
 
       private
 
-      def application_name
-        Rails.application.class.module_parent.name
+      def root_path
+        "/"
       end
     end
   end

data/lib/plutonium/version.rb

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

data/lib/plutonium.rb

@@ -23,67 +23,23 @@ module Plutonium
     Rails.logger
   end
 
-  def self.development?
-    ActiveModel::Type::Boolean.new.cast(ENV["PLUTONIUM_DEV"]).present?
-  end
-
-  def self.stylesheet_link
-    return @stylesheet_link if defined?(@stylesheet_link) && !development?
-
-    if development?
-      base_dir = "/plutonium-assets/build"
-      filename = "plutonium-dev.css"
-    else
-      base_dir = "/plutonium-assets"
-      filename = "plutonium.css"
-    end
-
-    file = stylesheet_manifest[filename]
-    @stylesheet_link = "#{base_dir}/#{file}"
+  def self.application_name
+    @application_name || Rails.application.class.module_parent.name
   end
 
-  def self.script_link
-    return @script_link if defined?(@script_link) && !development?
-
-    filename = "plutonium-app.js"
-    base_dir = if development?
-      "/plutonium-assets/build"
-    else
-      "/plutonium-assets"
-    end
-
-    file = script_manifest[filename]
-    @script_link = "#{base_dir}/#{file}"
+  def self.application_name=(application_name)
+    @application_name = application_name
   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)))
+  def self.development?
+    ActiveModel::Type::Boolean.new.cast(ENV["PLUTONIUM_DEV"]).present?
   end
 
-  def self.script_manifest
-    return @script_manifest if defined?(@script_manifest) && !development?
+  def self.eager_load_rails!
+    return if Rails.env.production? && defined?(@rails_eager_loaded)
 
-    manifest = if development?
-      "js.dev.manifest"
-    else
-      "js.manifest"
-    end
-    @script_manifest = JSON.parse(File.read(root.join(manifest)))
+    Rails.application.eager_load! unless Rails.application.config.eager_load
+    @rails_eager_loaded = true
   end
 end
 

data/lib/tasks/create_rodauth_admin.rake

@@ -0,0 +1,16 @@
+namespace :rodauth do
+  desc "Create a Rodauth admin account"
+  task admin: :environment do
+    # require "rodauth"
+    # require "active_record"
+    require "tty-prompt"
+
+    prompt = TTY::Prompt.new
+    email = ENV["EMAIL"] || prompt.ask("email:", required: true)
+    # password = SecureRandom.hex
+    # password = ENV["PASSWORD"] || prompt.mask("password:", required: true)
+    # password_confirm = ENV["PASSWORD"] || prompt.mask("password:", required: true)
+
+    RodauthApp.rodauth(:admin).create_account(login: email)
+  end
+end