#rlsbl.lint.languages

#rlsbl.lint.languages

The single table of languages the library linter knows about.

This taxonomy is deliberately NOT the release-target taxonomy. python is not pypi: a language is a way of writing source files, a target is a way of publishing them, and one language can back several targets (Kotlin and Java both arrive here as maven). Keeping the two apart is the point -- the mapping between them is a single property on the target (ReleaseTarget.lint_language), not a name comparison repeated per call site.

Before this table, the same four language names were spelled out in several separate places: _detect_languages (manifest -> language), _create_linter (language -> linter class), and _DEFAULT_EXCLUDE_PATTERNS (language -> excludes). Each one could drift from the others, and one of them answered an unknown language with a bare return None that the caller silently ignored. Everything now derives from LANGUAGES, and an unknown language is a hard error rather than a quiet no-op.

Import scanning is deliberately absent from this table. The per-language scanners are driven directly by rlsbl.import_scanners and rlsbl.dep_validation -- the linters' own scan_imports methods for Python and npm, and rlsbl.lint.go_ast.scan_imports per file for Go. The table used to carry an import_scanner factory beside them that nothing in production ever consulted.

#LintLanguage

Everything the linter knows about one language.

Attributes:

• name: the language identifier used in config filenames

(.rlsbl/lint/<name>.toml) and in LanguageLinter.language.

• manifests: filenames whose presence in a project root means this

language is present. Any one of them is enough.

• default_excludes: glob patterns excluded from lint by default, so

boundary checks look at production code rather than tests and examples.

• default_forbidden_imports: the imports a library of this language must

not reach for, applied when the project ships no .rlsbl/lint/<name>.toml. Empty for languages whose linter shells out to the project's own tool.

• linters: maps a parser type to a zero-argument factory. The

"default" key is used when the project declares no parser preference; "regex" is the opt-out for environments without a tree-sitter grammar. A language offering only one implementation lists it under both keys.

#detect

def detect(self, project_path: str) -> bool

Return True when any declared manifest exists in project_path.

#linter

def linter(self, parser_type: str)

Instantiate the linter for parser_type, defaulting to AST.

#get_language

def get_language(name: str) -> LintLanguage

Return the declared language, or raise naming the unknown one.

Deliberately not .get(name, None): a caller that reached here with a language the table does not declare has a bug, and returning None would turn that bug into a silently skipped lint.