plutonium 0.14.1 → 0.15.0.pre.rc1

data/lib/plutonium/core/controllers/base.rb

@@ -1,101 +0,0 @@
-module Plutonium
-  module Core
-    module Controllers
-      module Base
-        extend ActiveSupport::Concern
-        include Plutonium::Core::Controllers::Bootable
-        include Plutonium::Core::Controllers::EntityScoping
-
-        included do
-          add_flash_types :success, :warning, :error
-
-          before_action do
-            next unless defined?(ActiveStorage)
-
-            ActiveStorage::Current.url_options = {protocol: request.protocol, host: request.host, port: request.port}
-          end
-
-          helper Plutonium::Helpers
-          helper_method :make_page_title, :resource_url_for, :resource_url_args_for, :root_path
-
-          append_view_path File.expand_path("app/views", Plutonium.root)
-          layout -> { turbo_frame_request? ? false : "resource" }
-        end
-
-        private
-
-        def set_page_title(page_title)
-          @page_title = page_title
-        end
-
-        def make_page_title(title)
-          [title.presence, helpers.application_name].compact.join(" | ")
-        end
-
-        #
-        # Returns a dynamic list of args to be used with `url_for`, which considers the route namespace and nesting.
-        # The current entity and parent record (for nested routes) are inserted appropriately, ensuring that generated URLs
-        # obey the current routing.
-        #
-        # e.g., of route helpers that will be invoked given the output of this method
-        #
-        # - when invoked in a root route (/acme/dashboard/users)
-        #
-        # `resource_url_args_for User`                   => `entity_users_*`
-        # `resource_url_args_for @user`                  => `entity_user_*`
-        # `resource_url_args_for @user, action: :edit`   => `edit_entity_user_*`
-        # `resource_url_args_for @user, Post`            => `entity_user_posts_*`
-        #
-        # - when invoked in a nested route (/acme/dashboard/users/1/post/1)
-        #
-        # `resource_url_args_for Post`                   => `entity_user_posts_*`
-        # `resource_url_args_for @post`                  => `entity_user_post_*`
-        # `resource_url_args_for @post, action: :edit`   => `edit_entity_user_post_*`
-        #
-        # @param [Class, ApplicationRecord] *args arguments you would normally pass to `url_for`
-        # @param [Symbol] action optional action to invoke, e.g., :new, :edit
-        # @param [ApplicationRecord] parent the parent record for nested routes, if any
-        # @param [Hash] kwargs additional keyword arguments to pass to `url_for`
-        #
-        # @return [Hash] args to pass to `url_for`
-        #
-        def resource_url_args_for(*args, action: nil, parent: nil, **kwargs)
-          url_args = {**kwargs, action: action}.compact
-
-          controller_chain = [current_package.to_s]
-          [*args].compact.each_with_index do |element, index|
-            if element.is_a?(Class)
-              controller_chain << element.to_s.pluralize
-            else
-              controller_chain << element.class.to_s.pluralize
-              if index == args.length - 1
-                url_args[:id] = element.to_param
-                url_args[:action] ||= :show
-              else
-                url_args[element.model_name.singular_route_key.to_sym] = element.to_param
-              end
-            end
-          end
-          url_args[:controller] = "/#{controller_chain.join("::").underscore}"
-
-          url_args[:"#{parent.model_name.singular_route_key}_id"] = parent.to_param if parent.present?
-          if scoped_to_entity? && scoped_entity_strategy == :path
-            url_args[scoped_entity_param_key] = current_scoped_entity
-          end
-
-          url_args
-        end
-
-        def resource_url_for(...)
-          send(current_package.name.underscore.to_sym).url_for(resource_url_args_for(...))
-        end
-
-        def root_path(*)
-          return send(:"#{scoped_entity_param_key}_root_path", *) if scoped_to_entity? && scoped_entity_strategy == :path
-
-          super(*)
-        end
-      end
-    end
-  end
-end

data/lib/plutonium/core/controllers/presentable.rb

@@ -1,65 +0,0 @@
-module Plutonium
-  module Core
-    module Controllers
-      module Presentable
-        extend ActiveSupport::Concern
-
-        included do
-          helper_method :presentable_attributes, :present_associations?
-        end
-
-        private
-
-        def resource_presenter(resource_class, resource_record)
-          presenter_class = "#{resource_class}Presenter".constantize
-          presenter_class.new resource_context, resource_record
-        end
-
-        def current_presenter
-          @current_presenter ||= resource_presenter resource_class, @resource_record
-        end
-
-        def presentable_attributes
-          @presentable_attributes ||= begin
-            presentable_attributes = permitted_attributes
-            presentable_attributes -= [scoped_entity_param_key, :"#{scoped_entity_param_key}_id"] if scoped_to_entity?
-            presentable_attributes -= [parent_input_param, :"#{parent_input_param}_id"] if current_parent.present?
-            presentable_attributes
-          end
-        end
-
-        def build_collection
-          Plutonium::Core::Ui::Collection.new(
-            resource_class:,
-            records: @resource_records,
-            fields: current_presenter.defined_field_renderers_for(*presentable_attributes),
-            actions: current_presenter.actions,
-            pager: @pagy,
-            search_object: @search_object
-          )
-        end
-
-        def build_detail
-          Plutonium::Core::Ui::Detail.new(
-            resource_class:,
-            record: resource_record,
-            fields: current_presenter.defined_field_renderers_for(*presentable_attributes),
-            associations: current_presenter.defined_association_renderers_for(*permitted_associations),
-            actions: current_presenter.actions
-          )
-        end
-
-        def build_form
-          Plutonium::Core::Ui::Form.new(
-            record: resource_record,
-            inputs: current_presenter.defined_field_inputs_for(*presentable_attributes)
-          )
-        end
-
-        def present_associations?
-          current_parent.nil?
-        end
-      end
-    end
-  end
-end

data/lib/plutonium/core/controllers/queryable.rb

@@ -1,28 +0,0 @@
-using Plutonium::Refinements::ParameterRefinements
-
-module Plutonium
-  module Core
-    module Controllers
-      module Queryable
-        extend ActiveSupport::Concern
-
-        included do
-          helper_method :resource_query_params
-        end
-
-        def resource_query_object(resource_class, params)
-          query_object_class = "#{resource_class}QueryObject".constantize
-          query_object_class.new resource_context, params
-        end
-
-        def current_query_object
-          @current_query_object ||= resource_query_object resource_class, resource_query_params
-        end
-
-        def resource_query_params
-          (params[:q]&.nilify&.to_unsafe_h || {}).with_indifferent_access
-        end
-      end
-    end
-  end
-end

data/lib/plutonium/pkg/app.rb

@@ -1,35 +0,0 @@
-# frozen_string_literal: true
-
-module Plutonium
-  module Pkg
-    module App
-      extend ActiveSupport::Concern
-      include Base
-
-      included do
-        isolate_namespace to_s.deconstantize.constantize
-      end
-
-      class_methods do
-        include Plutonium::Concerns::ResourceValidatable
-        attr_reader :scoped_entity_class, :scoped_entity_strategy, :scoped_entity_param_key
-
-        def scope_to_entity(entity_class, strategy: :path, param_key: nil)
-          validate_resource! entity_class
-
-          @scoped_entity_class = entity_class
-          @scoped_entity_strategy = strategy
-          @scoped_entity_param_key = param_key || entity_class.model_name.singular_route_key.to_sym
-        end
-
-        def scoped_to_entity?
-          scoped_entity_class.present?
-        end
-
-        def dom_id
-          module_parent_name.underscore.dasherize
-        end
-      end
-    end
-  end
-end

data/lib/plutonium/pkg/concerns/resource_validatable.rb

@@ -1,36 +0,0 @@
-# frozen_string_literal: true
-
-module Plutonium
-  module Pkg
-    module Concerns
-      # Provides methods for validating Plutonium resources
-      module ResourceValidatable
-        extend ActiveSupport::Concern
-
-        # Custom error class for invalid resources
-        class InvalidResourceError < StandardError; end
-
-        private
-
-        # Validates if a given resource is a valid Plutonium::Resource::Record
-        #
-        # @param resource [Object] The resource to validate
-        # @raise [InvalidResourceError] If the resource is not valid
-        # @return [void]
-        def validate_resource!(resource)
-          unless valid_resource?(resource)
-            raise InvalidResourceError, "#{resource} is not a valid Plutonium::Resource::Record"
-          end
-        end
-
-        # Checks if a given resource is a valid Plutonium::Resource::Record
-        #
-        # @param resource [Object] The resource to check
-        # @return [Boolean] True if the resource is valid, false otherwise
-        def valid_resource?(resource)
-          resource.is_a?(Class) && resource.include?(Plutonium::Resource::Record)
-        end
-      end
-    end
-  end
-end

data/lib/plutonium/pkg/feature.rb

@@ -1,18 +0,0 @@
-module Plutonium
-  module Pkg
-    module Feature
-      extend ActiveSupport::Concern
-      include Base
-
-      included do
-        initializer :append_migrations do |app|
-          unless app.root.to_s.match root.to_s
-            config.paths["db/migrate"].expanded.each do |expanded_path|
-              app.config.paths["db/migrate"] << expanded_path
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/plutonium/policy/initializer.rb

@@ -1,22 +0,0 @@
-require "pundit"
-
-module Plutonium
-  module Policy
-    module Initializer
-      def initialize(context, record)
-        authorize!(context)
-
-        @context = context
-        @record = record
-      end
-
-      private
-
-      attr_reader :context, :record
-
-      def authorize!(context)
-        raise Pundit::NotAuthorizedError, "must be logged in" unless context&.user
-      end
-    end
-  end
-end

data/lib/plutonium/policy/scope.rb

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

data/lib/plutonium/pundit/context.rb

@@ -1,18 +0,0 @@
-require "pundit"
-
-module Plutonium
-  module Pundit
-    class Context < ::Pundit::Context
-      def initialize(*, package:, **)
-        super(*, **)
-        @package = package
-      end
-
-      private
-
-      def policy_finder(record)
-        PolicyFinder.new(record, package: @package)
-      end
-    end
-  end
-end

data/lib/plutonium/pundit/policy_finder.rb

@@ -1,25 +0,0 @@
-require "pundit"
-
-module Plutonium
-  module Pundit
-    class PolicyFinder < ::Pundit::PolicyFinder
-      def initialize(*, package:)
-        super(*)
-        @package = package
-      end
-
-      attr_reader :package
-
-      def policy
-        policy_internal([package, object]) || policy_internal(object)
-      end
-
-      private
-
-      def policy_internal(object)
-        klass = find(object)
-        klass.is_a?(String) ? klass.safe_constantize : klass
-      end
-    end
-  end
-end

data/lib/plutonium/resource/policy_context.rb

@@ -1,5 +0,0 @@
-module Plutonium
-  module Resource
-    PolicyContext = Data.define :user, :resource_context
-  end
-end

data/lib/plutonium/resource_register.rb

@@ -1,83 +0,0 @@
-# frozen_string_literal: true
-
-module Plutonium
-  # ResourceRegister manages the registration and lookup of resources.
-  class ResourceRegister
-    include Plutonium::SmartCache
-    include Concerns::ResourceValidatable
-
-    # Custom error class for frozen register operations
-    class FrozenRegisterError < StandardError; end
-
-    def initialize
-      @resources = Set.new
-      @frozen = false
-    end
-
-    # Registers a new resource with the register.
-    #
-    # @param resource [Class] The resource class to be registered.
-    # @raise [Plutonium::Concerns::ResourceValidatable::InvalidResourceError] If the resource is not a valid Plutonium::Resource::Record.
-    # @raise [FrozenRegisterError] If the register is frozen.
-    # @return [void]
-    def register(resource)
-      raise FrozenRegisterError, "Cannot modify frozen resource register" if @frozen
-
-      validate_resource!(resource)
-      @resources.add(resource.to_s)
-    end
-
-    # Returns an array of all registered resource classes and freezes the register.
-    #
-    # @return [Array<Class>] An array of registered resource classes.
-    def resources
-      freeze
-      @resources.map(&:constantize)
-    end
-    memoize_unless_reloading :resources
-
-    # Returns a hash mapping route keys to their corresponding resource classes.
-    # This method will freeze the register if it hasn't been frozen already.
-    #
-    # @return [Hash{Symbol => Class}] A hash where keys are route keys and values are resource classes.
-    def route_key_lookup
-      freeze
-      resources.to_h do |resource|
-        [resource.model_name.singular_route_key.to_sym, resource]
-      end
-    end
-    memoize_unless_reloading :route_key_lookup
-
-    # Clears all registered resources and invalidates the cache.
-    #
-    # @return [void]
-    def clear
-      @resources.clear
-      @frozen = false
-      invalidate_cache
-    end
-
-    # Checks if the register is frozen.
-    #
-    # @return [Boolean] True if the register is frozen, false otherwise.
-    def frozen?
-      @frozen
-    end
-
-    private
-
-    # Freezes the register
-    #
-    # @return [Boolean] Always returns true
-    def freeze
-      @frozen ||= true
-    end
-
-    # Invalidates the memoization cache
-    #
-    # @return [void]
-    def invalidate_cache
-      flush_smart_cache
-    end
-  end
-end

data/lib/plutonium/smart_cache.rb

@@ -1,151 +0,0 @@
-# frozen_string_literal: true
-
-module Plutonium
-  # The SmartCache module provides flexible caching mechanisms for classes and objects,
-  # allowing for both inline caching and method-level memoization.
-  #
-  # This module is designed to optimize performance by caching results
-  # when class caching is enabled (typically in production),
-  # while ensuring fresh results when caching is disabled (typically in development).
-  #
-  # This implementation is thread-safe.
-  #
-  # @example Including SmartCache in a class
-  #   class MyClass
-  #     include Plutonium::SmartCache
-  #
-  #     def my_method(arg)
-  #       cache_unless_reloading("my_method_#{arg}") { expensive_operation(arg) }
-  #     end
-  #
-  #     def another_method(arg)
-  #       # Method implementation
-  #     end
-  #     memoize_unless_reloading :another_method
-  #   end
-  module SmartCache
-    extend ActiveSupport::Concern
-
-    included do
-      class_attribute :_memoized_results, instance_writer: false, default: Concurrent::Map.new
-    end
-
-    # Caches the result of the given block unless class caching is disabled.
-    #
-    # @param cache_key [String] A unique key to identify the cached result
-    # @yield The block whose result will be cached
-    # @return [Object] The result of the block, either freshly computed or from cache
-    #
-    # @example Using cache_unless_reloading inline
-    #   def fetch_user_data(user_id)
-    #     cache_unless_reloading("user_data_#{user_id}") do
-    #       UserDataService.fetch(user_id)
-    #     end
-    #   end
-    #
-    # @note This method uses Rails.application.config.cache_classes
-    #       to determine whether to cache or not. When cache_classes is false
-    #       (typical in development), it will always yield to get a fresh result.
-    #       When true (typical in production), it will use the cache.
-    def cache_unless_reloading(cache_key, &block)
-      return yield unless should_cache?
-
-      @cached_results ||= Concurrent::Map.new
-      @cached_results.compute_if_absent(cache_key) { yield }
-    end
-
-    # Flushes the smart cache for the specified keys or all keys if none are specified.
-    #
-    # @param keys [Array<Symbol, String>, Symbol, String] The cache key(s) to flush
-    # @return [void]
-    #
-    # @example Flushing specific cache keys
-    #   flush_smart_cache([:user_data, :product_list])
-    #
-    # @example Flushing all cache keys
-    #   flush_smart_cache
-    #
-    # @note This method clears both inline caches and memoized method results.
-    def flush_smart_cache(keys = nil)
-      keys = Array(keys).map(&:to_sym)
-      if keys.present?
-        @cached_results&.delete_if { |k, _| keys.include?(k.to_sym) }
-        keys.each { |key| self.class._memoized_results.delete(key) }
-      else
-        @cached_results&.clear
-        self.class._memoized_results.clear
-      end
-    end
-
-    # Determines whether caching should be performed based on the current Rails configuration.
-    #
-    # @return [Boolean] true if caching should be performed, false otherwise
-    # @note This method uses Rails.application.config.cache_classes to determine caching behavior.
-    #       When cache_classes is false (typical in development), it returns false.
-    #       When true (typical in production), it returns true.
-    def should_cache?
-      Rails.application.config.cache_classes
-    end
-
-    class_methods do
-      # Memoizes the result of the specified method unless class caching is disabled.
-      #
-      # @param method_name [Symbol] The name of the method to memoize
-      # @return [void]
-      #
-      # @example Memoizing a method
-      #   class User
-      #     include Plutonium::SmartCache
-      #
-      #     def expensive_full_name_calculation
-      #       # Complex name calculation
-      #     end
-      #     memoize_unless_reloading :expensive_full_name_calculation
-      #   end
-      #
-      # @note This method uses Rails.application.config.cache_classes to determine
-      #       whether to memoize or not. When cache_classes is false (typical in development),
-      #       it will always call the original method. When true (typical in production),
-      #       it will use memoization, caching results for each unique set of arguments.
-      def memoize_unless_reloading(method_name)
-        original_method = instance_method(method_name)
-        define_method(method_name) do |*args|
-          if should_cache?
-            cache = self.class._memoized_results[method_name] ||= Concurrent::Map.new
-            cache.compute_if_absent(args.hash.to_s) { original_method.bind_call(self, *args) }
-          else
-            original_method.bind_call(self, *args)
-          end
-        end
-      end
-    end
-  end
-
-  # Configuration:
-  #  The caching behavior is controlled by the Rails configuration option config.cache_classes:
-  #
-  #  - When false (typical in development):
-  #    - Classes are reloaded on each request.
-  #    - cache_unless_reloading always yields fresh results.
-  #    - memoize_unless_reloading always calls the original method.
-  #
-  #  - When true (typical in production):
-  #    - Classes are cached.
-  #    - cache_unless_reloading uses cached results.
-  #    - memoize_unless_reloading uses memoized results, caching for each unique set of arguments.
-  #
-  # Best Practices:
-  #  - Use meaningful and unique cache keys to avoid collisions.
-  #  - Be mindful of memory usage, especially with large cached results.
-  #  - Consider cache expiration strategies for long-running processes.
-  #  - Use cache_unless_reloading for fine-grained control within methods.
-  #  - Use memoize_unless_reloading for entire methods, especially those with expensive computations.
-  #
-  # Thread Safety:
-  #  - This implementation is thread-safe.
-  #  - It uses Concurrent::Map from the concurrent-ruby gem for thread-safe caching.
-  #
-  # Testing:
-  #  - In your test environment, you may want to control caching behavior explicitly.
-  #  - You can mock or stub Rails.application.config.cache_classes or override should_cache? as needed in your tests.
-end