Rakefile

# frozen_string_literal: true

require 'English'
$LOAD_PATH.unshift File.expand_path('.')

require 'base64'
require 'json'
require 'rake'
require 'net/http'
require 'net/telnet'
require 'stringio'
require 'fileutils'
require 'open-uri'
require 'git'
require 'find'

Rake.application.instance_variable_set(:@name, 'go')
orig_verbose = verbose
verbose(false)

require 'rake_tasks/bazel'
require 'rake_tasks/common'

$DEBUG = orig_verbose != Rake::FileUtilsExt::DEFAULT
$DEBUG = true if ENV['debug'] == 'true'

verbose($DEBUG)
SeleniumRake.git = Git.open(__dir__)

# Load language-specific rake files within namespaces
namespace(:java) { load 'rake_tasks/java.rake' }
namespace(:rb) { load 'rake_tasks/ruby.rake' }
namespace(:ruby) { load 'rake_tasks/ruby.rake' }
namespace(:py) { load 'rake_tasks/python.rake' }
namespace(:python) { load 'rake_tasks/python.rake' }
namespace(:node) { load 'rake_tasks/node.rake' }
namespace(:js) { load 'rake_tasks/node.rake' }
namespace(:javascript) { load 'rake_tasks/node.rake' }
namespace(:dotnet) { load 'rake_tasks/dotnet.rake' }
namespace(:rust) { load 'rake_tasks/rust.rake' }
namespace(:grid) { load 'rake_tasks/grid.rake' }

# If it looks like a bazel target, build it with bazel
rule(%r{//.*}) do |task|
  Bazel.execute('build', %w[], task.name)
end

task default: [:grid]
task grid: [:'java:grid']

# ./go update_browser stable
# ./go update_browser beta
desc 'Update pinned browser versions'
task :update_browsers, [:channel] do |_task, arguments|
  chrome_channel = arguments[:channel] || 'Stable'
  chrome_channel = 'beta' if chrome_channel == 'early-stable'
  args = Array(chrome_channel) ? ['--', "--chrome_channel=#{chrome_channel.capitalize}"] : []

  puts 'pinning updated browsers and drivers'
  Bazel.execute('run', args, '//scripts:pinned_browsers')
  SeleniumRake.git.add('common/repositories.bzl')
end

desc 'Update Selenium Manager to latest release'
task :update_manager do |_task, _arguments|
  puts 'Updating Selenium Manager references'
  Bazel.execute('run', [], '//scripts:selenium_manager')

  SeleniumRake.git.add('common/selenium_manager.bzl')
end

desc 'Update Chrome DevTools support'
task :update_cdp, [:channel] do |_task, arguments|
  chrome_channel = arguments[:channel] || 'stable'
  chrome_channel = 'beta' if chrome_channel == 'early-stable'
  args = Array(chrome_channel) ? ['--', "--chrome_channel=#{chrome_channel.capitalize}"] : []

  puts "Updating Chrome DevTools references to include latest from #{chrome_channel} channel"
  Bazel.execute('run', args, '//scripts:update_cdp')

  ['common/devtools/',
   'dotnet/src/webdriver/DevTools/',
   'dotnet/src/webdriver/Selenium.WebDriver.csproj',
   'dotnet/test/common/DevTools/',
   'dotnet/test/common/CustomDriverConfigs/',
   'dotnet/selenium-dotnet-version.bzl',
   'java/src/org/openqa/selenium/devtools/',
   'javascript/selenium-webdriver/BUILD.bazel',
   'py/BUILD.bazel',
   'rb/lib/selenium/devtools/',
   'rb/Gemfile.lock',
   'Rakefile'].each { |file| SeleniumRake.git.add(file) }
end

desc 'Update AUTHORS file'
task :authors do
  puts 'Updating AUTHORS file'
  sh "(git log --use-mailmap --format='%aN <%aE>' ; cat .OLD_AUTHORS) | sort -uf > AUTHORS"
  SeleniumRake.git.add('AUTHORS')
end

# Example: `./go prep_release[4.31.0,early-stable]`
# Equivalent to .github/workflows/pre-release.yml in a single command
desc 'Update everything in preparation for a release'
task :prep_release, [:version, :channel] do |_task, arguments|
  version = arguments[:version]

  Rake::Task['update_browsers'].invoke(arguments[:channel])
  Rake::Task['update_cdp'].invoke(arguments[:channel])
  Rake::Task['update_manager'].invoke
  Rake::Task['java:update'].invoke
  Rake::Task['authors'].invoke
  Rake::Task['all:version'].invoke(version)
  Rake::Task['all:changelogs'].invoke
end

desc 'Run all linters (skip languages with: ./go lint -rb -rust)'
task :lint do |_task, arguments|
  failures = []

  begin
    Rake::Task['all:lint'].invoke(*arguments.to_a)
  rescue StandardError => e
    failures << e.message
  end

  puts 'Linting Bazel files...'
  begin
    Bazel.execute('run', [], '//:buildifier')
  rescue StandardError => e
    failures << "buildifier: #{e.message}"
  end

  puts 'Linting shell scripts and GitHub Actions...'
  begin
    shellcheck = Bazel.execute('build', [], '@multitool//tools/shellcheck')
    Bazel.execute('run', ['--', '-shellcheck', shellcheck], '@multitool//tools/actionlint:cwd')
  rescue StandardError => e
    failures << "shellcheck/actionlint: #{e.message}"
  end

  puts 'Updating copyright headers...'
  begin
    Bazel.execute('run', [], '//scripts:update_copyright')
  rescue StandardError => e
    failures << "copyright: #{e.message}"
  end

  raise "Lint failed:\n#{failures.join("\n")}" unless failures.empty?
end

# Legacy aliases - call namespaced tasks
task 'selenium-server-standalone' => 'java:grid'
task 'selenium-java' => 'java:client'
task javadocs: 'java:docs'
task 'java-release-zip': 'java:package'
task 'maven-install': 'java:install'
task 'publish-maven' => 'java:release'
task 'publish-maven-snapshot' do
  Rake::Task['java:release'].invoke('nightly')
end
task 'release-java' => 'java:release'

namespace :all do
  desc 'Pin dependencies for all languages'
  task :pin do
    Rake::Task['java:pin'].invoke
    Rake::Task['rb:pin'].invoke
    Rake::Task['rust:pin'].invoke
    Rake::Task['node:pin'].invoke
    Rake::Task['dotnet:pin'].invoke
  end

  desc 'Update dependencies for all languages'
  task :update do
    Rake::Task['java:update'].invoke
    Rake::Task['rb:update'].invoke
    Rake::Task['rust:update'].invoke
    Rake::Task['node:update'].invoke
    Rake::Task['dotnet:update'].invoke
  end

  desc 'Build all API Documentation'
  task :docs do |_task, arguments|
    args = arguments.to_a
    Rake::Task['java:docs'].invoke(*args)
    Rake::Task['py:docs'].invoke(*args)
    Rake::Task['rb:docs'].invoke(*args)
    Rake::Task['dotnet:docs'].invoke(*args)
    Rake::Task['node:docs'].invoke(*args)
  end

  desc 'Build all artifacts for all language bindings'
  task :build do |_task, arguments|
    Rake::Task['java:build'].invoke(*arguments.to_a)
    Rake::Task['py:build'].invoke(*arguments.to_a)
    Rake::Task['rb:build'].invoke(*arguments.to_a)
    Rake::Task['dotnet:build'].invoke(*arguments.to_a)
    Rake::Task['node:build'].invoke(*arguments.to_a)
  end

  desc 'Package or build stamped artifacts for distribution in GitHub Release assets'
  task :package do |_task, arguments|
    Rake::Task['java:package'].invoke(*arguments.to_a)
    Rake::Task['dotnet:package'].invoke(*arguments.to_a)
  end

  desc 'Validate release credentials for all languages'
  task :check_credentials do |_task, arguments|
    args = arguments.to_a
    failures = []
    %w[java py rb dotnet node].each do |lang|
      Rake::Task["#{lang}:check_credentials"].invoke(*args)
    rescue StandardError => e
      failures << "#{lang}: #{e.message}"
    end
    raise "Credential check failed:\n#{failures.join("\n")}" unless failures.empty?
  end

  desc 'Verify all packages are published to their registries'
  task :verify do
    failures = []
    %w[java py rb dotnet node].each do |lang|
      Rake::Task["#{lang}:verify"].invoke
    rescue StandardError => e
      failures << "#{lang}: #{e.message}"
    end
    raise "Verification failed:\n#{failures.join("\n")}" unless failures.empty?
  end

  desc 'Release all artifacts for all language bindings'
  task :release do |_task, arguments|
    args = arguments.to_a.include?('nightly') ? ['nightly'] : []
    Rake::Task['java:release'].invoke(*args)
    Rake::Task['py:release'].invoke(*args)
    Rake::Task['rb:release'].invoke(*args)
    Rake::Task['dotnet:release'].invoke(*args)
    Rake::Task['node:release'].invoke(*args)
  end

  desc 'Run linters for all languages (skip with: ./go all:lint -rb -rust)'
  task :lint do |_task, arguments|
    all_langs = %w[java py rb node dotnet rust]
    skip = arguments.to_a.select { |a| a.start_with?('-') }.map { |a| a.delete_prefix('-') }
    invalid = skip - all_langs
    raise "Unknown languages: #{invalid.join(', ')}. Valid: #{all_langs.join(', ')}" if invalid.any?

    langs = all_langs - skip
    failures = []
    langs.each do |lang|
      puts "Linting #{lang}..."
      Rake::Task["#{lang}:lint"].invoke
    rescue StandardError => e
      failures << "#{lang}: #{e.message}"
    end
    raise "Lint failed:\n#{failures.join("\n")}" unless failures.empty?
  end

  desc 'Update all versions'
  task :version, [:version] do |_task, arguments|
    version = arguments[:version] || 'nightly'
    puts "Updating all versions to #{version}"

    Rake::Task['java:version'].invoke(version)
    Rake::Task['rb:version'].invoke(version)
    Rake::Task['node:version'].invoke(version)
    Rake::Task['py:version'].invoke(version)
    Rake::Task['dotnet:version'].invoke(version)
    Rake::Task['rust:version'].invoke(version)

    unless version == 'nightly'
      major_minor = arguments[:version][/^\d+\.\d+/]
      file = '.github/ISSUE_TEMPLATE/bug-report.yml'
      old_version_pattern = /The latest released version of Selenium is (\d+\.\d+)/

      text = File.read(file).gsub(old_version_pattern, "The latest released version of Selenium is #{major_minor}")
      File.write(file, text)
      SeleniumRake.git.add(file)
    end
  end

  desc 'Update all changelogs'
  task :changelogs do |_task, _arguments|
    puts 'Updating all changelogs'
    Rake::Task['java:changelogs'].invoke
    Rake::Task['rb:changelogs'].invoke
    Rake::Task['node:changelogs'].invoke
    Rake::Task['py:changelogs'].invoke
    Rake::Task['dotnet:changelogs'].invoke
    Rake::Task['rust:changelogs'].invoke
  end
end