fixed test coverage and updated commands

Author: ndbroadbent

.github/workflows/test.yml

@@ -84,7 +84,7 @@ jobs:
           fi
 
       - name: RuboCop (Linting/Formatting)
-        run: scripts/rubocop.rb
+        run: bin/rubocop
 
       - name: Sorbet (Typecheck)
         run: scripts/typecheck.sh

AGENTS.md

@@ -32,8 +32,8 @@
 
 - Ruby typecheck: `scripts/typecheck.sh`
 - Next.js typecheck: `cd site && pnpm exec tsc --noEmit`
-- Lint Ruby: `scripts/rubocop.rb`
-- Format Ruby: `scripts/rubocop.rb -A`
+- Lint Ruby: `bin/rubocop`
+- Format Ruby: `bin/rubocop -A`
 - Format JS/TS/JSON: `scripts/prettier.sh --write`
 - Lint JS/TS/JSON: `scripts/prettier.sh --check`
 - Spellcheck: `scripts/spellcheck.sh`

Taskfile.ruby.yml

@@ -14,12 +14,12 @@ tasks:
   lint:
     desc: Run RuboCop
     cmds:
-      - bundle exec ruby scripts/rubocop.rb
+      - bundle exec ruby bin/rubocop
 
   lint:fix:
     desc: Auto-correct RuboCop offenses
     cmds:
-      - bundle exec ruby scripts/rubocop.rb -A
+      - bundle exec ruby bin/rubocop -A
 
   check-generated:
     desc: Ensure generated Ruby structs are up to date (CI safe)

bin/rubocop

@@ -1,4 +1,5 @@
 #!/usr/bin/env ruby
+# typed: true
 # frozen_string_literal: true
 
 #
@@ -24,4 +25,21 @@ end
 require "rubygems"
 require "bundler/setup"
 
+# In restricted environments, RuboCop cache writes may fail. Disable or redirect cache.
+begin
+  cache_root = File.expand_path("../tmp/rubocop_cache", __dir__)
+  Dir.mkdir(File.expand_path("../tmp", __dir__)) unless Dir.exist?(File.expand_path("../tmp", __dir__))
+  Dir.mkdir(cache_root) unless Dir.exist?(cache_root)
+rescue
+  cache_root = nil
+end
+
+unless ARGV.any? { |a| a == "--no-cache" || a.start_with?("--cache") }
+  if cache_root
+    ARGV.unshift("--cache-root", cache_root)
+  else
+    ARGV.unshift("--no-cache")
+  end
+end
+
 load Gem.bin_path("rubocop", "rubocop")

lefthook.yml

@@ -82,14 +82,5 @@ pre-commit:
 
           - name: rubocop
             glob: '*.rb'
-            run: scripts/rubocop.rb -A {staged_files}
+            run: bin/rubocop -A {staged_files}
             stage_fixed: true
-
-# Optional: Run full test suite manually with lefthook run full-tests
-full-tests:
-  parallel: false
-
-  # Run complete test suite including Rails integration tests
-  all-tests:
-    run: scripts/all_tests.sh
-    fail_text: 'Full test suite failed'

lib/log_struct/rails_boot_banner_silencer.rb

@@ -18,14 +18,14 @@ def self.install!
       patch!
     end
 
-    sig { void }
+    sig { returns(T::Boolean) }
     def self.patch!
       begin
         require "rails/command"
         require "rails/commands/server/server_command"
       rescue LoadError
         # Best-effort – if Rails isn't available yet we'll try again later
-        return
+        return false
       end
 
       server_command = T.let(nil, T.untyped)
@@ -36,9 +36,10 @@ def self.patch!
         server_command = nil
       end
       # rubocop:enable Sorbet/ConstantsFromStrings
-      return unless server_command
+      return false unless server_command
 
       patch_server_command(server_command)
+      true
     end
 
     sig { params(server_command: T.untyped).void }

test/log_struct/rails_boot_banner_silencer_test.rb

@@ -0,0 +1,225 @@
+# typed: true
+# frozen_string_literal: true
+
+require "test_helper"
+
+class RailsBootBannerSilencerTest < Minitest::Test
+  SILENCER = LogStruct::RailsBootBannerSilencer
+  SERVER_MODULE = LogStruct::RailsBootBannerSilencer::ServerCommandSilencer
+
+  def setup
+    @original_argv = ARGV.dup
+    @installed_flag = SILENCER.instance_variable_get(:@installed)
+    SILENCER.instance_variable_set(:@installed, false)
+    store_server_mode
+  end
+
+  def teardown
+    ARGV.replace(@original_argv)
+    SILENCER.instance_variable_set(:@installed, @installed_flag)
+    restore_server_mode
+  end
+
+  def test_install_skips_patch_when_not_running_server
+    ARGV.replace(["console"])
+
+    SILENCER.stub(:patch!, proc { flunk("patch! should not run without server arg") }) do
+      SILENCER.install!
+    end
+  end
+
+  def test_patch_handles_missing_rails_gracefully
+    with_kernel_require_raising_load_error do
+      SILENCER.instance_variable_set(:@installed, false)
+      ARGV.replace(["server"])
+
+      refute(SILENCER.patch!)
+    end
+  end
+
+  def test_patch_patches_when_server_command_is_available
+    stub_class = build_server_command_stub
+    ARGV.replace(["server"])
+
+    stub_const_get(stub_class) do
+      assert(SILENCER.patch!)
+    end
+
+    assert_includes(stub_class.ancestors, SERVER_MODULE)
+  end
+
+  def test_patch_server_command_is_idempotent
+    stub_class = build_server_command_stub
+    SILENCER.patch_server_command(stub_class)
+    first_count = count_silencer_modules(stub_class)
+    SILENCER.patch_server_command(stub_class)
+
+    assert_equal(first_count, count_silencer_modules(stub_class))
+  end
+
+  def test_perform_marks_server_mode_and_delegates
+    stub_class = build_server_command_stub
+    SILENCER.patch_server_command(stub_class)
+
+    instance = stub_class.new
+    result = instance.perform(:foo, :bar)
+
+    assert_equal(:original_perform, result)
+    assert_equal([:foo, :bar], instance.performed_args)
+    assert(LogStruct.instance_variable_get(:@server_mode))
+  end
+
+  def test_print_boot_information_consumes_banner_lines
+    stub_class = build_server_command_stub
+    SILENCER.patch_server_command(stub_class)
+    instance = stub_class.new
+
+    processed = []
+    boot_called = false
+
+    LogStruct::Integrations::Puma.stub(:emit_boot_if_needed!, proc { boot_called = true }) do
+      LogStruct::Integrations::Puma.stub(:process_line, ->(line) { processed << line }) do
+        Rails.stub(:version, "8.0.1") do
+          Rails.stub(:env, "test") do
+            instance.print_boot_information("Stub::Server", "http://localhost:3000")
+          end
+        end
+      end
+    end
+
+    assert(boot_called)
+    assert_includes(processed, "=> Booting Server")
+    assert_includes(processed, "=> Rails 8.0.1 application starting in test http://localhost:3000")
+    assert_includes(processed, "=> Run `task-cli --help` for more startup options")
+  end
+
+  def test_print_boot_information_uses_fallbacks
+    stub_class = build_server_command_stub(executable: proc { raise "missing" })
+    SILENCER.patch_server_command(stub_class)
+    instance = stub_class.new
+    processed = []
+
+    LogStruct::Integrations::Puma.stub(:emit_boot_if_needed!, proc {}) do
+      LogStruct::Integrations::Puma.stub(:process_line, ->(line) { processed << line }) do
+        ActiveSupport::Inflector.stub(:demodulize, proc { raise "boom" }) do
+          Rails.stub(:version, proc { raise "no version" }) do
+            instance.print_boot_information(Object.new, nil)
+          end
+        end
+      end
+    end
+
+    assert_includes(processed, "=> Booting Puma")
+    assert_includes(processed, "=> Rails application starting")
+    assert_includes(processed, "=> Run `rails --help` for more startup options")
+  end
+
+  def test_lookup_executable_returns_default_when_missing
+    klass = Class.new do
+      prepend SERVER_MODULE
+
+      def perform(*)
+      end
+
+      def print_boot_information(_server, _url)
+      end
+    end
+
+    value = klass.new.send(:lookup_executable)
+
+    assert_equal("rails", value)
+  end
+
+  private
+
+  def store_server_mode
+    @had_server_mode = LogStruct.instance_variable_defined?(:@server_mode)
+    @stored_server_mode = LogStruct.instance_variable_get(:@server_mode) if @had_server_mode
+    LogStruct.instance_variable_set(:@server_mode, false)
+  end
+
+  def restore_server_mode
+    if @had_server_mode
+      LogStruct.instance_variable_set(:@server_mode, @stored_server_mode)
+    elsif LogStruct.instance_variable_defined?(:@server_mode)
+      LogStruct.remove_instance_variable(:@server_mode)
+    end
+  end
+
+  def build_server_command_stub(executable: "task-cli")
+    Class.new do
+      class << self
+        attr_reader :prepended_modules
+
+        def prepend(mod)
+          (@prepended_modules ||= []) << mod
+          super
+        end
+      end
+
+      attr_reader :performed_args
+
+      define_method(:perform) do |*args|
+        @performed_args = args
+        :original_perform
+      end
+
+      define_method(:print_boot_information) do |_server, _url|
+        :original_print
+      end
+
+      define_method(:executable) do
+        executable.is_a?(Proc) ? executable.call : executable
+      end
+    end
+  end
+
+  def stub_const_get(stub_class)
+    original_const_get = Object.method(:const_get)
+
+    Object.stub(:const_get,
+      ->(name, inherit = true) do
+        if name == "Rails::Command::ServerCommand"
+          stub_class
+        else
+          original_const_get.call(name, inherit)
+        end
+      end) do
+      yield
+    end
+  end
+
+  def count_silencer_modules(stub_class)
+    stub_class.singleton_class.ancestors.count { |ancestor| ancestor == SERVER_MODULE }
+  end
+
+  def with_kernel_require_raising_load_error
+    kernel_singleton = Kernel.singleton_class
+    kernel_module = Kernel
+
+    kernel_module.class_eval do
+      alias_method :__logstruct_original_instance_require, :require
+      define_method(:require) do |*_args|
+        raise LoadError, "missing"
+      end
+    end
+    kernel_singleton.class_eval do
+      alias_method :__logstruct_original_module_require, :require
+      define_method(:require) do |*_args|
+        raise LoadError, "missing"
+      end
+    end
+    yield
+  ensure
+    kernel_module.class_eval do
+      remove_method :require
+      alias_method :require, :__logstruct_original_instance_require
+      remove_method :__logstruct_original_instance_require
+    end
+    kernel_singleton.class_eval do
+      remove_method :require
+      alias_method :require, :__logstruct_original_module_require
+      remove_method :__logstruct_original_module_require
+    end
+  end
+end