A platform for community discussion. Free, open, simple.
#!/usr/bin/env ruby
# frozen_string_literal: true
require "optparse"
require "open3"
require "pathname"
require "shellwords"
PROJECT_ROOT = File.expand_path("..", __dir__)
PROJECT_ROOT_PATH = Pathname.new(PROJECT_ROOT)
PROJECT_ROOT_REALPATH = PROJECT_ROOT_PATH.realpath
INVOCATION_PWD = Dir.pwd
LintAborted = Class.new(StandardError)
module Logging
def log(message)
puts "[bin/lint] #{message}"
end
def debug(message)
puts message if @verbose
end
end
module ArgumentBatcher
MAX_ARGV_BYTES = 100_000
def self.batches(files, per_file_overhead: 1)
batches = [[]]
size = 0
files.each do |file|
entry = file.bytesize + per_file_overhead
if size + entry > MAX_ARGV_BYTES && batches.last.any?
batches << []
size = 0
end
batches.last << file
size += entry
end
batches
end
end
class ExternalLinter
include Logging
RUBY_EXTENSIONS = %w[rb rake thor].freeze
PRETTIER_EXTENSIONS = %w[css scss js gjs cjs mjs ts gts mts cts].freeze
ESLINT_EXTENSIONS = %w[js gjs cjs mjs ts gts mts cts].freeze
STYLELINT_EXTENSIONS = %w[scss].freeze
JS_EXTENSIONS = (PRETTIER_EXTENSIONS + ESLINT_EXTENSIONS + STYLELINT_EXTENSIONS).uniq.freeze
PNPM = %w[pnpm --ignore-workspace].freeze
JS_LINTERS = [
["prettier", PRETTIER_EXTENSIONS, %w[--write], %w[--list-different]],
["eslint", ESLINT_EXTENSIONS, %w[--fix], %w[--quiet]],
["stylelint", STYLELINT_EXTENSIONS, %w[--fix], []],
].freeze
attr_reader :results
def initialize(root, files, fix:, verbose: false)
root_path = Pathname.new(root).realpath
@root = root
@files = files.map { |file| Pathname.new(file).realpath.relative_path_from(root_path).to_s }
@fix = fix
@verbose = verbose
@results = []
end
def run
ruby_files = @files.select { |file| ruby_file?(file) }
js_files = @files.select { |file| extension_in?(file, JS_EXTENSIONS) }
skipped = @files - ruby_files - js_files
log "No external-plugin linter for: #{skipped.join(", ")}" if skipped.any?
run_ruby_linters(ruby_files) if ruby_files.any?
run_js_linters(js_files) if js_files.any?
end
private
def extension_in?(file, extensions)
extensions.include?(File.extname(file)[1..])
end
def ruby_file?(file)
extension_in?(file, RUBY_EXTENSIONS) || File.basename(file) == "Gemfile"
end
def run_cmd(*cmd, env: {})
debug "Running: #{cmd.shelljoin} (cwd: #{@root})"
system(env, *cmd, chdir: @root)
end
def run_linter(name, *cmd)
log "Running #{name}..."
@results << [name, run_cmd(*cmd)]
end
def run_ruby_linters(files)
log "Installing bundler dependencies in #{@root}..."
frozen = @fix ? {} : { "BUNDLE_FROZEN" => "true" }
return @results << ["bundle install", false] unless run_cmd("bundle", "install", env: frozen)
ArgumentBatcher
.batches(files)
.each do |batch|
run_linter("stree", "bundle", "exec", "stree", @fix ? "write" : "check", *batch)
end
ArgumentBatcher
.batches(files)
.each do |batch|
run_linter("rubocop", "bundle", "exec", "rubocop", *(@fix ? ["--autocorrect"] : []), *batch)
end
end
def run_js_linters(files)
log "Installing pnpm dependencies in #{@root}..."
frozen = @fix ? [] : ["--frozen-lockfile"]
return @results << ["pnpm install", false] unless run_cmd(*PNPM, "i", *frozen)
JS_LINTERS.each do |name, extensions, fix_args, check_args|
matching = files.select { |file| extension_in?(file, extensions) }
next if matching.empty?
ArgumentBatcher
.batches(matching)
.each { |batch| run_linter(name, *PNPM, name, *(@fix ? fix_args : check_args), *batch) }
end
end
end
class LefthookLinter
include Logging
EVERYTHING = ["ALL FILES"].freeze
SELECTORS = %i[recent staged unstaged wip].freeze
SKIPPED_PATHS = %w[config/database.yml].freeze
SKIPPED_SEGMENTS = %w[node_modules vendor tmp .git].freeze
LINTABLE_EXTENSIONS = %w[
rb
rake
thor
js
gjs
cjs
mjs
ts
gts
mts
cts
hbs
scss
css
yml
yaml
md
json
].freeze
RUBY_SHEBANG = "#!/usr/bin/env ruby"
CORE_FRONTEND_PATHS = %w[frontend/ plugins/ themes/].freeze
CORE_STYLESHEET_PATHS = %w[app/assets/stylesheets/].freeze
DEVELOPER_DOCS_PATH = "docs/developer-guides/"
DEVELOPER_DOCS_EXTENSIONS = %w[md json mjs yml].freeze
FILE_FLAG_BYTES = "--file".bytesize + 2
def initialize(options = {})
@fix = options[:fix]
@verbose = options[:verbose]
@files = options[:files] || []
@selector = SELECTORS.find { |name| options[name] }
@results = []
end
def run
lint(determine_files)
print_summary
@results.all? { |_, ok| ok }
rescue LintAborted => e
warn "[bin/lint] #{e.message}"
false
end
private
def lint(files)
return run_lefthook(@fix ? "fix-all" : "lints", []) if files.equal?(EVERYTHING)
return if files.empty?
core, external = partition_files(files)
core, skipped = core.partition { |file| core_lintable_file?(file) }
log "No core linter for: #{skipped.join(", ")}" if skipped.any?
run_lefthook(hook, core) if core.any?
external.each { |root, paths| run_external(root, paths) }
end
def hook
if @selector == :staged
@fix ? "fix-staged" : "pre-commit"
else
@fix ? "fix-files" : "lint-files"
end
end
def print_summary
failed = @results.reject { |_, ok| ok }
if failed.any?
failed.each { |name, _| log "#{name} failed" }
elsif @results.empty?
log "Nothing was linted"
else
log "All lints passed"
end
end
def determine_files
return EVERYTHING if @selector.nil? && @files.empty?
if @selector && @files.any?
warn "[bin/lint] Ignoring file arguments: a selector flag takes precedence"
end
resolved = source_paths.map { |path| resolve_path(path) }
files = resolved.flat_map(&:first).uniq
if @selector.nil?
resolved.filter_map(&:last).each { |problem| warn "[bin/lint] Skipping #{problem}" }
raise LintAborted, "Nothing to lint" if files.empty?
end
files
end
def source_paths
return source_files if @selector
@files.map { |file| normalize_relative_path(file) }
end
def source_files
case @selector
when :recent
recent_files
when :staged
staged_files
when :unstaged
unstaged_files
when :wip
wip_files
else
@files
end
end
def resolve_path(path)
if File.directory?(path)
expanded = expand_directory(path)
return expanded, expanded.empty? ? "#{path}: no lintable files" : nil
end
return [], "#{path}: does not exist" unless File.file?(path)
return [], "#{path}: not a lintable file type" unless lintable_file?(path)
[[path], nil]
end
def expand_directory(path)
files =
git_lines(
"ls-files",
"--cached",
"--others",
"--exclude-standard",
"--",
path,
on_failure: :ignore,
)
files = [path] if files.empty?
files
.flat_map { |file| File.directory?(file) ? Dir.glob(File.join(file, "**", "*")) : file }
.select { |file| File.file?(file) && lintable_file?(file) }
end
def git_lines(*args, on_failure: :abort)
output, error, status = Open3.capture3("git", *args)
return output.lines.map(&:strip).reject(&:empty?) if status.success?
return [] if on_failure == :ignore
raise LintAborted, "git #{args.first} failed: #{error.lines.first&.strip}"
end
def recent_files
git_lines("log", "-50", "--name-only", "--pretty=format:") +
git_lines("ls-files", "--others", "--exclude-standard") + staged_files + unstaged_files
end
def staged_files
git_lines("diff", "--cached", "--name-only")
end
def unstaged_files
git_lines("diff", "--name-only")
end
def wip_files
git_lines("diff", "main...HEAD", "--name-only") + staged_files + unstaged_files
end
def core_lintable_file?(file)
return false if outside_project?(file)
return true if file == "Gemfile"
extension = File.extname(file)[1..]
return ruby_script?(file) if extension.nil? || extension.empty?
return true if ExternalLinter::RUBY_EXTENSIONS.include?(extension)
return true if %w[yml yaml].include?(extension)
if file.start_with?(DEVELOPER_DOCS_PATH)
return true if DEVELOPER_DOCS_EXTENSIONS.include?(extension)
end
return false unless ExternalLinter::JS_EXTENSIONS.include?(extension)
paths = CORE_FRONTEND_PATHS
paths += CORE_STYLESHEET_PATHS if %w[css scss].include?(extension)
paths.any? { |path| file.start_with?(path) }
end
def lintable_file?(file)
return false if skipped_project_path?(file)
return true if File.basename(file) == "Gemfile"
extension = File.extname(file)[1..]
return ruby_script?(file) if extension.nil? || extension.empty?
LINTABLE_EXTENSIONS.include?(extension)
end
def outside_project?(file)
file.start_with?("../")
end
def skipped_project_path?(file)
return false if outside_project?(file)
return true if SKIPPED_PATHS.include?(file)
file.split("/").any? { |segment| SKIPPED_SEGMENTS.include?(segment) }
end
def ruby_script?(file)
return false unless file.start_with?("bin/") && File.file?(file)
File.open(file, &:readline).strip == RUBY_SHEBANG
rescue StandardError
false
end
def partition_files(files)
grouped = files.group_by { |file| external_plugin_root(file) }
[grouped.delete(nil) || [], grouped]
end
def external_plugin_root(file)
return standalone_plugin_root(file) if outside_project?(file)
return nil unless file.start_with?("plugins/")
parts = file.split("/")
return nil if parts.length < 2
plugin_dir = "plugins/#{parts[1]}"
return nil if bundled_plugins.include?(plugin_dir)
File.join(PROJECT_ROOT, plugin_dir)
end
def standalone_plugin_root(file)
path = Pathname.new(file).realpath
return nil if path.to_s.start_with?("#{PROJECT_ROOT_REALPATH}#{File::SEPARATOR}")
path.ascend.find { |dir| dir.join("plugin.rb").file? }&.to_s
end
def bundled_plugins
@bundled_plugins ||=
begin
output, status = Open3.capture2(File.join(PROJECT_ROOT, "script", "list_bundled_plugins"))
raise LintAborted, "Failed to list bundled plugins" unless status.success?
Set.new(output.lines.map(&:strip).reject(&:empty?))
end
end
def run_external(root, files)
linter = ExternalLinter.new(root, files, fix: @fix, verbose: @verbose)
linter.run
relative = Pathname.new(root).relative_path_from(PROJECT_ROOT_PATH)
linter.results.each { |name, ok| @results << ["#{name} (#{relative})", ok] }
end
def run_lefthook(hook, files)
log "Running core linters via lefthook..."
outcomes =
ArgumentBatcher
.batches(files, per_file_overhead: FILE_FLAG_BYTES)
.map do |batch|
cmd = ["pnpm", "lefthook", "run", hook]
batch.each { |file| cmd << "--file" << file }
cmd << "--verbose" if @verbose
debug "Running: #{cmd.shelljoin}"
system({ "LEFTHOOK" => "1" }, *cmd)
end
@results << ["core linters", outcomes.all?]
end
def normalize_relative_path(file)
absolute = File.expand_path(file, INVOCATION_PWD)
Pathname.new(absolute).relative_path_from(PROJECT_ROOT_PATH).to_s
rescue ArgumentError
file
end
end
def parse_options
options = {}
OptionParser
.new do |parser|
parser.banner = "Usage: bin/lint [options] [files|directories...]"
parser.on("-h", "--help", "Show this help message") do
puts parser
puts
puts "Examples:"
puts " bin/lint # Lint all files"
puts " bin/lint --recent # Lint recently changed files"
puts " bin/lint --staged # Lint only staged files"
puts " bin/lint --unstaged # Lint only unstaged files"
puts " bin/lint --wip # Lint staged + unstaged + files changed since main"
puts " bin/lint --fix app.rb file2.js # Fix specific file/s"
puts " bin/lint app/models/*.rb # Lint multiple files"
puts " bin/lint frontend/discourse/app/ # Lint all lintable files in directory"
puts
puts "Linters are configured in lefthook.yml."
exit
end
parser.on("-f", "--fix", "Attempt to automatically fix issues") { options[:fix] = true }
parser.on("-r", "--recent", "Lint recently changed files (last 50 commits)") do
options[:recent] = true
end
parser.on("--staged", "Lint only staged files") { options[:staged] = true }
parser.on("--unstaged", "Lint only unstaged files") { options[:unstaged] = true }
parser.on("--wip", "Lint work-in-progress: staged + unstaged + files changed since main") do
options[:wip] = true
end
parser.on("-v", "--verbose", "Show verbose output") { options[:verbose] = true }
end
.parse!
options[:files] = ARGV unless ARGV.empty?
options
rescue OptionParser::ParseError => e
abort "[bin/lint] #{e.message}\nRun `bin/lint --help` for usage."
end
if __FILE__ == $0
options = parse_options
Dir.chdir(PROJECT_ROOT) # rubocop:disable Discourse/NoChdir
exit 1 unless LefthookLinter.new(options).run
end