How to list enabled and disabled rules?

[peturingi]

How can I obtain lists of enabled and disabled rules -- those that are and are not used by an invocation of ruff check given the current configuration?

[MichaReiser]

You can run ruff check --show-settings (in the folder you want to see the resolved configuration).

It outputs the resolved configuration file and it has one section that lists the enabled rules

...

# Linter Settings
linter.exclude = []
linter.project_root = "/home/micha/astral/ruff"
linter.rules.enabled = [
	MultipleImportsOnOneLine,
	ModuleImportNotAtTopOfFile,
	MultipleStatementsOnOneLineColon,
	MultipleStatementsOnOneLineSemicolon,
	UselessSemicolon,
	NoneComparison,
	TrueFalseComparison,
	NotInTest,
	NotIsTest,
	TypeComparison,
	BareExcept,
	LambdaAssignment,
	AmbiguousVariableName,
	AmbiguousClassName,
	AmbiguousFunctionName,
	IOError,
	SyntaxError,
	UnusedImport,
	ImportShadowedByLoopVar,
	UndefinedLocalWithImportStar,
	LateFutureImport,
	UndefinedLocalWithImportStarUsage,
	UndefinedLocalWithNestedImportStarUsage,
	FutureFeatureNotDefined,
	PercentFormatInvalidFormat,
	PercentFormatExpectedMapping,
	PercentFormatExpectedSequence,
	PercentFormatExtraNamedArguments,
	PercentFormatMissingArgument,
	PercentFormatMixedPositionalAndNamed,
	PercentFormatPositionalCountMismatch,
	PercentFormatStarRequiresSequence,
	PercentFormatUnsupportedFormatCharacter,
	StringDotFormatInvalidFormat,
	StringDotFormatExtraNamedArguments,
	StringDotFormatExtraPositionalArguments,
	StringDotFormatMissingArguments,
	StringDotFormatMixingAutomatic,
	FStringMissingPlaceholders,
	MultiValueRepeatedKeyLiteral,
	MultiValueRepeatedKeyVariable,
	ExpressionsInStarAssignment,
	MultipleStarredExpressions,
	AssertTuple,
	IsLiteral,
	InvalidPrintSyntax,
	IfTuple,
	BreakOutsideLoop,
	ContinueOutsideLoop,
	YieldOutsideFunction,
	ReturnOutsideFunction,
	DefaultExceptNotLast,
	ForwardAnnotationSyntaxError,
	RedefinedWhileUnused,
	UndefinedName,
	UndefinedExport,
	UndefinedLocal,
	UnusedVariable,
	UnusedAnnotation,
	RaiseNotImplemented,
]
...

[alwaysmpe]

I couldn't find any real way to get rules that don't run so I hacked together the following:

from subprocess import check_output
import json
import toml

def main():
    json_out = check_output('poetry run ruff rule --all --output-format json', shell=True).decode()
    all_rules = parse_rule_descriptions(json_out)
    all_codes = set(all_rules.keys())

    disabled = disabled_rules()
    standard_rules = get_enabld(False)
    preview_rules = get_enabld(True)

    always_enabled = standard_rules & preview_rules
    standard_only_enabled = standard_rules - always_enabled
    preview_only_enabled = preview_rules - always_enabled
    ever_enabled_rules = standard_rules | standard_only_enabled | preview_only_enabled
    implicitly_disabled = all_codes - (ever_enabled_rules | disabled)
    disabled_in_preview = all_codes - (disabled | preview_rules | implicitly_disabled)
    disabled_in_standard = all_codes - (disabled | standard_rules | implicitly_disabled)

    print('the following rules are always enabled:')
    for rule in sorted(always_enabled):
        print(rule, all_rules[rule]['name'], '\n', all_rules[rule]['summary'],'\n')

    print('-' * 100)


    print('the following rules are only disabled in preview:')
    for rule in sorted(disabled_in_preview):
        print(rule, all_rules[rule]['name'], '\n', all_rules[rule]['summary'],'\n')

    print('-' * 100)

    print('the following rules are only disabled in standard:')
    for rule in sorted(disabled_in_standard):
        print(rule, all_rules[rule]['name'], '\n', all_rules[rule]['summary'],'\n')

    print('-' * 100)

    print('the following rules are implicitly always disabled:')
    for rule in sorted(implicitly_disabled):
        print(rule, all_rules[rule]['name'], '\n', all_rules[rule]['summary'],'\n')

    print('-' * 100)

    print('total rules:', len(all_codes))
    print('rules that always run:', len(always_enabled))
    print('rules only disabled in preview:', len(disabled_in_preview))
    print('rules only disabled in standard:', len(disabled_in_standard))
    print('rules disabled by pyproject:', len(disabled))
    print('rules that implicitly never run:', len(implicitly_disabled))


def disabled_rules():
    config = toml.load('pyproject.toml')
    return set(config['tool']['ruff']['lint']['ignore'])


def get_enabld(preview: bool):
    preview_str = '--preview' if preview else ''
    settings_out = check_output(f'poetry run ruff check {preview_str} --show-settings', shell=True).decode()
    enabled_rules = parse_enabled_rules(settings_out)
    return enabled_rules


def parse_enabled_rules(config_out: str) -> set[str]:
    start_str = 'linter.rules.enabled = ['
    start_idx = config_out.index(start_str)
    start_idx += len(start_str) + 1
    config_out = config_out[start_idx:]

    end_idx = config_out.index(']') - 1
    config_out = config_out[:end_idx]

    lines = config_out.split('\n')
    rules = {
        line[:-2].split('(')[1]
        for line in lines
    }
    return rules


def parse_rule_descriptions(data: str) -> dict:
    return {
        element['code']: {
            "name": element["name"],
            "summary": element["summary"],
        }
        for element in json.loads(data)
    }


main()