# frozen_string_literal: true

require "bundler/gem_tasks"

require "rake/testtask"

require "rspec/core/rake_task"

require "yard"

require "yard/mattr_accessor_handler"

require "rails/version"

require "simplecov"

require "simplecov-console"

RSpec::Core::RakeTask.new(:spec)

Rake::TestTask.new(:test) do |t|

t.libs << "test"

t.libs << "lib"

t.test_files = FileList["test/**/*_test.rb"]

end

Rake::TestTask.new(:engine_test) do |t|

t.libs << "test_engine"

t.libs << "test_engine/lib"

t.test_files = FileList["test_engine/**/*_test.rb"]

end

desc "Runs benchmarks against components"

task :partial_benchmark do

ruby "./performance/partial_benchmark.rb"

end

task :translatable_benchmark do

ruby "./performance/translatable_benchmark.rb"

end

task :slots_benchmark do

ruby "./performance/slots_benchmark.rb"

end

task :inline_components_benchmark do

ruby "./performance/inline_benchmark.rb"

end

namespace :coverage do

task :report do

require "simplecov"

require "simplecov-console"

SimpleCov.minimum_coverage 100

SimpleCov.collate Dir["{coverage,simplecov-resultset-*}/.resultset.json"], "rails" do

formatter SimpleCov::Formatter::Console

end

end

end

namespace :docs do

task :build do

YARD::Rake::YardocTask.new do |t|

t.options = ["--no-output", "-q"]

end

Rake::Task["yard"].execute

registry = YARD::RegistryStore.new

registry.load!(".yardoc")

meths =

registry

.get("ViewComponent::Base")

.meths

.select do |method|

!method.tag(:private) &&

method.path.include?("ViewComponent::Base") &&

method.visibility == :public &&

!method[:name].to_s.start_with?("_") # Ignore methods we mark as internal by prefixing with underscores

end.sort_by { |method| method[:name] }

instance_methods_to_document = meths.select { |method| method.scope != :class }

class_methods_to_document = meths.select { |method| method.scope == :class }

configuration_methods_to_document = registry.get("ViewComponent::Config").meths.select(&:reader?)

test_helper_methods_to_document = registry

.get("ViewComponent::TestHelpers")

.meths

.sort_by { |method| method[:name] }

.select do |method|

!method.tag(:private) &&

method.visibility == :public

end

require "rails"

require "action_controller"

require "view_component"

require "docs/docs_builder_component"

error_keys = registry.keys.select { |key| key.to_s.include?("Error::MESSAGE") }.map(&:to_s)

docs = ActionController::Base.renderer.render(

ViewComponent::DocsBuilderComponent.new(

sections: [

ViewComponent::DocsBuilderComponent::Section.new(

heading: "Class methods",

methods: class_methods_to_document

),

ViewComponent::DocsBuilderComponent::Section.new(

heading: "Instance methods",

methods: instance_methods_to_document

),

ViewComponent::DocsBuilderComponent::Section.new(

heading: "Configuration",

methods: configuration_methods_to_document,

show_types: false

),

ViewComponent::DocsBuilderComponent::Section.new(

heading: "ViewComponent::TestHelpers",

methods: test_helper_methods_to_document

),

ViewComponent::DocsBuilderComponent::Section.new(

heading: "Errors",

error_klasses: error_keys

)

]

)

).chomp

if ENV["RAILS_ENV"] != "test"

File.open("docs/api.md", "w") do |f|

f.puts(docs)

end

end

end

end

desc "Verify the app boots with eager_load=true (catches missing requires)"

task :eager_load_check do

puts "Checking eager loading..."

# Boot a minimal Rails app with eager_load enabled. Using a bare app (no

# components) ensures Zeitwerk doesn't accidentally autoload

# ViewComponent::Base before processing the engine's controllers — exactly

# the scenario that triggers NameError in a fresh host application.

result = system(

{"RAILS_ENV" => "test"},

"bundle", "exec", "ruby", "-e", <<~RUBY

require "rails"

require "action_controller/railtie"

require "view_component"

class EagerLoadCheckApp < Rails::Application

config.eager_load = true

config.secret_key_base = "test"

config.hosts.clear

end

EagerLoadCheckApp.initialize!

RUBY

)

abort("Eager loading check failed!") unless result

puts "Eager loading check passed"

end

task :all_tests do

ENV["RAILS_ENV"] = "test"

if ENV["MEASURE_COVERAGE"]

SimpleCov.start do

command_name "rails#{Rails::VERSION::STRING}-ruby#{RUBY_VERSION}"

enable_coverage :branch

formatter SimpleCov::Formatter::Console

end

end

puts "Checking eager loading"

Rake::Task["eager_load_check"].invoke

puts

puts

puts "Running Minitests"

Rake::Task["test"].invoke

puts

puts

puts "Running Minitests for Rails Engine compatibility"

Rake::Task["engine_test"].invoke

puts

puts

puts "Running RSpecs"

Rake::Task["spec"].invoke

end

task default: [:all_tests]