rage-rb 1.27.0 → 1.28.0

data/lib/rage/cli.rb

@@ -4,65 +4,14 @@ require "thor"
 require "rack"
 require "rage/version"
 
+require "rage/cli/base"
 require "rage/cli/skills"
+require "rage/cli/openapi"
+require "rage/cli/code_generator"
+require "rage/cli/new_app_generator"
 
-module Rage
-  class CLICodeGenerator < Thor
-    include Thor::Actions
-
-    def self.source_root
-      File.expand_path("templates", __dir__)
-    end
-
-    desc "migration NAME", "Generate a new migration"
-    def migration(name = nil)
-      return help("migration") if name.nil?
-
-      setup
-      Rake::Task["db:new_migration"].invoke(name)
-    end
-
-    desc "model NAME", "Generate a new model"
-    def model(name = nil)
-      return help("model") if name.nil?
-
-      setup
-      migration("create_#{name.pluralize}")
-      @model_name = name.classify
-      template("model-template/model.rb", "app/models/#{name.singularize.underscore}.rb")
-    end
-
-    desc "controller NAME", "Generate a new controller"
-    def controller(name = nil)
-      return help("controller") if name.nil?
-
-      setup
-      unless defined?(ActiveSupport::Inflector)
-        raise LoadError, <<~ERR
-          ActiveSupport::Inflector is required to run this command. Add the following line to your Gemfile:
-          gem "activesupport", require: "active_support/inflector"
-        ERR
-      end
-
-      # remove trailing Controller if already present
-      normalized_name = name.sub(/_?controller$/i, "")
-      @controller_name = "#{normalized_name.camelize}Controller"
-      file_name = "#{normalized_name.underscore}_controller.rb"
-
-      template("controller-template/controller.rb", "app/controllers/#{file_name}")
-    end
-
-    private
-
-    def setup
-      @setup ||= begin
-        require "rake"
-        load "Rakefile"
-      end
-    end
-  end
-
-  class CLI < Thor
+module Rage::CLI
+  class App < Base
     def self.exit_on_failure?
       true
     end
@@ -74,7 +23,7 @@ module Rage
       return help("new") if options.help? || path.nil?
 
       require "rage/all"
-      CLINewAppGenerator.start([path, options[:database]])
+      NewAppGenerator.start([path, options[:database]])
     end
 
     desc "s", "Start the app server"
@@ -232,11 +181,14 @@ module Rage
     end
 
     desc "skills", "Manage coding agent skills"
-    subcommand "skills", CLISkills
+    subcommand "skills", Skills
+
+    desc "openapi", "OpenAPI validation tools"
+    subcommand "openapi", OpenAPI
 
     map "generate" => :g
     desc "g TYPE", "Generate new code"
-    subcommand "g", CLICodeGenerator
+    subcommand "g", CodeGenerator
 
     map "--tasks" => :tasks
     desc "--tasks", "See the list of available tasks"
@@ -273,26 +225,6 @@ module Rage
 
     private
 
-    def environment
-      require File.expand_path("config/application.rb", Dir.pwd)
-
-      if Rage.config.internal.rails_mode
-        require File.expand_path("config/environment.rb", Dir.pwd)
-      end
-    end
-
-    def set_env(options)
-      if options[:environment]
-        ENV["RAGE_ENV"] = ENV["RAILS_ENV"] = options[:environment]
-      elsif ENV["RAGE_ENV"]
-        ENV["RAILS_ENV"] = ENV["RAGE_ENV"]
-      elsif ENV["RAILS_ENV"]
-        ENV["RAGE_ENV"] = ENV["RAILS_ENV"]
-      else
-        ENV["RAGE_ENV"] = ENV["RAILS_ENV"] = "development"
-      end
-    end
-
     def linked_rake_tasks
       require "rake"
       Rake::TaskManager.record_task_metadata = true
@@ -371,67 +303,4 @@ module Rage
       end
     end
   end
-
-  class CLINewAppGenerator < Thor::Group
-    include Thor::Actions
-    argument :path, type: :string
-    argument :database, type: :string, required: false
-
-    def self.source_root
-      File.expand_path("templates", __dir__)
-    end
-
-    def setup
-      @use_database = !database.nil?
-    end
-
-    def create_directory
-      empty_directory(path)
-    end
-
-    def copy_files
-      inject_templates
-    end
-
-    def install_database
-      return unless @use_database
-
-      @app_name = path.tr("-", "_").downcase
-      append_to_file "#{path}/Gemfile", <<~RUBY
-
-        gem "#{get_db_gem_name}"
-        gem "activerecord"
-        gem "standalone_migrations", require: false
-      RUBY
-
-      inject_templates("db-templates")
-      inject_templates("db-templates/#{database}")
-    end
-
-    private
-
-    def inject_templates(from = nil)
-      root = "#{self.class.source_root}/#{from}"
-
-      Dir.glob("*", base: root).each do |template|
-        next if File.directory?("#{root}/#{template}")
-
-        *template_path_parts, template_name = template.split("-")
-        template("#{root}/#{template}", [path, *template_path_parts, template_name].join("/"))
-      end
-    end
-
-    def get_db_gem_name
-      case database
-      when "mysql"
-        "mysql2"
-      when "trilogy"
-        "trilogy"
-      when "postgresql"
-        "pg"
-      when "sqlite3"
-        "sqlite3"
-      end
-    end
-  end
 end

data/lib/rage/code_loader.rb

@@ -37,6 +37,7 @@ class Rage::CodeLoader
     load("#{Rage.root}/config/routes.rb")
 
     reload_components
+    Rage.config.run_hooks_for(:after_reload)
   end
 
   # in Rails mode - reset the routes; everything else will be done by Rails
@@ -47,6 +48,7 @@ class Rage::CodeLoader
     Rage.__router.reset_routes
 
     reload_components
+    Rage.config.run_hooks_for(:after_reload)
   end
 
   def reloading?
@@ -54,7 +56,9 @@ class Rage::CodeLoader
   end
 
   def check_updated!
-    current_watched = @autoload_path.glob("**/*.rb") + Rage.root.glob("config/routes.rb") + Rage.root.glob("config/openapi_components.*")
+    current_watched = @autoload_path.glob("**/*.{rb,erb}") + Rage.root.glob("config/routes.rb") + Rage.root.glob("config/openapi_components.*")
+    current_watched += Rage.config.code_loader.reload_paths.flat_map { |pattern| Rage.root.glob(pattern) }
+
     current_update_at = current_watched.max_by { |path| path.exist? ? path.mtime.to_f : 0 }&.mtime.to_f
     return false if !@last_watched && !@last_update_at
 

data/lib/rage/configuration.rb

@@ -141,6 +141,15 @@ class Rage::Configuration
     push_hook(block, :after_initialize)
   end
 
+  # Schedule a block of code to run after Rage has reloaded the application code in development. Use this to reset state or re-initialize dependencies that cache application-level constants.
+  # @example
+  #   Rage.config.after_reload do
+  #     MyCache.clear
+  #   end
+  def after_reload(&block)
+    push_hook(block, :after_reload)
+  end
+
   # Register a custom renderer that generates overloads `render` on all controllers.
   # The block receives the object passed to `render` together with any additional keyword arguments.
   # The code inside the block is executed in the context of the controller instance, so you can access all usual controller methods in it.
@@ -256,6 +265,29 @@ class Rage::Configuration
   def log_tags
     @log_tags ||= LogTags.new
   end
+
+  # Allows configuring case-insensitive partial matches for redacting structured log context keys.
+  # Matching keys will have their values replaced with `"[REDACTED]"` before the log entry is written.
+  #
+  # @param keys [String, Symbol, Array<String, Symbol>, nil] one or more keys to redact
+  # @example Redact common secrets from structured logs
+  #   Rage.configure do
+  #     config.log_redact_keys = [:password, :token, :secret]
+  #   end
+  def log_redact_keys=(keys)
+    @log_redact_keys = Array(keys).filter_map { |key|
+      if !key.is_a?(String) && !key.is_a?(Symbol)
+        raise ArgumentError, "log redact keys have to be strings or symbols"
+      elsif !key.empty?
+        key.to_s
+      end
+    }.uniq
+  end
+
+  # @private
+  def log_redact_keys
+    @log_redact_keys || []
+  end
   # @!endgroup
 
   # @!group Telemetry Configuration
@@ -282,6 +314,14 @@ class Rage::Configuration
   end
   # @!endgroup
 
+  # @!group Code Loader Configuration
+  # Allows configuring code loader settings.
+  # @return [Rage::Configuration::CodeLoader]
+  def code_loader
+    @code_loader ||= CodeLoader.new
+  end
+  # @!endgroup
+
   # @!group Blocking Operation Pool Configuration
   # Allows configuring the thread pool for offloading native calls.
   # @return [Rage::Configuration::BlockingOperationPool]
@@ -435,7 +475,7 @@ class Rage::Configuration
     #   end
     def <<(reporter)
       validate_input!(reporter)
-      return self if @objects.include?(reporter)
+      raise ArgumentError, "#{reporter} is already registered" if @objects.include?(reporter)
 
       @objects << reporter
       Rage::Errors.__send__(:__register_reporter, reporter)
@@ -878,6 +918,7 @@ class Rage::Configuration
         @backend_options = parse_disk_backend_options(opts)
         Rage::Deferred::Backends::Disk
       when nil
+        @backend_options = {} if RUBY_VERSION.start_with?("3.3.")
         Rage::Deferred::Backends::Nil
       else
         raise ArgumentError, "unsupported backend value; supported keys are `:disk` and `nil`"
@@ -1123,6 +1164,29 @@ class Rage::Configuration
     attr_accessor :form_actions
   end
 
+  class CodeLoader
+    # @private
+    def initialize
+      @reload_paths = []
+    end
+
+    # @private
+    attr_reader :reload_paths
+
+    # Specify additional paths to watch for changes in development.
+    #
+    # @param paths [Array<Pathname, String>] glob patterns or directory paths to watch
+    # @example Watch HAML templates
+    #   Rage.configure do
+    #     config.code_loader.reload_paths = ["app/views/**/*.haml"]
+    #   end
+    def reload_paths=(paths)
+      @reload_paths = Array(paths).map do |path|
+        path.is_a?(Pathname) ? path : Pathname.new(path)
+      end
+    end
+  end
+
   class BlockingOperationPool
     # @!attribute enabled
     #   Enable a background thread pool for offloading native calls that can be executed outside the GVL, freeing
@@ -1165,7 +1229,11 @@ class Rage::Configuration
     #   end
     def <<(daemon)
       validate!(daemon)
+      raise ArgumentError, "#{daemon} is already registered" if @klasses.include?(daemon)
+
       @klasses << daemon
+
+      self
     end
 
     alias_method :push, :<<
@@ -1260,12 +1328,14 @@ class Rage::Configuration
     if @logger
       @logger.formatter = @log_formatter if @log_formatter
       @logger.level = @log_level if @log_level
+      @logger.log_redact_keys = @log_redact_keys if @log_redact_keys
     else
       @logger = Rage::Logger.new(nil)
     end
 
-    if @log_formatter && @logger.external_logger.is_a?(Rage::Logger::External::Dynamic)
+    if @log_formatter && @logger.external_logger.is_a?(Rage::Logger::External::Dynamic) && !@log_formatter_warning_shown
       puts "WARNING: changing the log formatter via `config.log_formatter=` has no effect when using a custom external logger."
+      @log_formatter_warning_shown = true
     end
 
     if @log_context

data/lib/rage/daemon.rb

@@ -174,7 +174,6 @@ class Rage::Daemon
               instance = new
               result = instance.perform
               break if result.equal?(Stop) || @__stopping
-              Rage.logger.warn("Daemon exited, restarting...")
             rescue => e
               break if @__stopping
               Rage.logger.error("Daemon failed with exception: #{e.class} (#{e.message}):\n#{e.backtrace.join("\n")}")
@@ -185,7 +184,11 @@ class Rage::Daemon
 
             # reset backoff if ran successfully for a while
             backoff = INITIAL_BACKOFF if Process.clock_gettime(Process::CLOCK_MONOTONIC) - started_at > BACKOFF_RESET_INTERVAL
-            sleep(backoff / 2 + rand * backoff / 2)
+
+            interval = (backoff / 2 + rand * backoff / 2).round(2)
+            Rage.logger.warn("Daemon exited, restarting in #{interval}s")
+            sleep(interval)
+
             backoff = (backoff * 2).clamp(INITIAL_BACKOFF, MAX_BACKOFF)
           end
         end