feat: 'ruff rule' provides more easily parsable JSON ouput

crates/ruff/src/commands/rule.rs

@@ -7,6 +7,7 @@ use serde::{Serialize, Serializer};
 use strum::IntoEnumIterator;
 
 use ruff_linter::FixAvailability;
+use ruff_linter::codes::RuleGroup;
 use ruff_linter::registry::{Linter, Rule, RuleNamespace};
 
 use crate::args::HelpFormat;
@@ -19,9 +20,11 @@ struct Explanation<'a> {
     summary: &'a str,
     message_formats: &'a [&'a str],
     fix: String,
+    fix_availability: FixAvailability,
     #[expect(clippy::struct_field_names)]
     explanation: Option<&'a str>,
     preview: bool,
+    status: RuleGroup,
 }
 
 impl<'a> Explanation<'a> {
@@ -36,8 +39,10 @@ impl<'a> Explanation<'a> {
             summary: rule.message_formats()[0],
             message_formats: rule.message_formats(),
             fix,
+            fix_availability: rule.fixable(),
             explanation: rule.explanation(),
             preview: rule.is_preview(),
+            status: rule.group(),
         }
     }
 }

crates/ruff/tests/integration_test.rs

@@ -951,6 +951,16 @@ fn rule_f401() {
     assert_cmd_snapshot!(ruff_cmd().args(["rule", "F401"]));
 }
 
+#[test]
+fn rule_f401_output_json() {
+    assert_cmd_snapshot!(ruff_cmd().args(["rule", "F401", "--output-format", "json"]));
+}
+
+#[test]
+fn rule_f401_output_text() {
+    assert_cmd_snapshot!(ruff_cmd().args(["rule", "F401", "--output-format", "text"]));
+}
+
 #[test]
 fn rule_invalid_rule_name() {
     assert_cmd_snapshot!(ruff_cmd().args(["rule", "RUF404"]), @r"
@@ -965,6 +975,34 @@ fn rule_invalid_rule_name() {
     ");
 }
 
+#[test]
+fn rule_invalid_rule_name_output_json() {
+    assert_cmd_snapshot!(ruff_cmd().args(["rule", "RUF404", "--output-format", "json"]), @r"
+    success: false
+    exit_code: 2
+    ----- stdout -----
+
+    ----- stderr -----
+    error: invalid value 'RUF404' for '[RULE]'
+
+    For more information, try '--help'.
+    ");
+}
+
+#[test]
+fn rule_invalid_rule_name_output_text() {
+    assert_cmd_snapshot!(ruff_cmd().args(["rule", "RUF404", "--output-format", "text"]), @r"
+    success: false
+    exit_code: 2
+    ----- stdout -----
+
+    ----- stderr -----
+    error: invalid value 'RUF404' for '[RULE]'
+
+    For more information, try '--help'.
+    ");
+}
+
 #[test]
 fn show_statistics() {
     let mut cmd = RuffCheck::default()

crates/ruff/tests/snapshots/integration_test__rule_f401_output_json.snap

@@ -0,0 +1,30 @@
+---
+source: crates/ruff/tests/integration_test.rs
+info:
+  program: ruff
+  args:
+    - rule
+    - F401
+    - "--output-format"
+    - json
+---
+success: true
+exit_code: 0
+----- stdout -----
+{
+  "name": "unused-import",
+  "code": "F401",
+  "linter": "Pyflakes",
+  "summary": "`{name}` imported but unused; consider using `importlib.util.find_spec` to test for availability",
+  "message_formats": [
+    "`{name}` imported but unused; consider using `importlib.util.find_spec` to test for availability",
+    "`{name}` imported but unused; consider removing, adding to `__all__`, or using a redundant alias",
+    "`{name}` imported but unused"
+  ],
+  "fix": "Fix is sometimes available.",
+  "fix_availability": "Sometimes",
+  "explanation": "## What it does\nChecks for unused imports.\n\n## Why is this bad?\nUnused imports add a performance overhead at runtime, and risk creating\nimport cycles. They also increase the cognitive load of reading the code.\n\nIf an import statement is used to check for the availability or existence\nof a module, consider using `importlib.util.find_spec` instead.\n\nIf an import statement is used to re-export a symbol as part of a module's\npublic interface, consider using a \"redundant\" import alias, which\ninstructs Ruff (and other tools) to respect the re-export, and avoid\nmarking it as unused, as in:\n\n```python\nfrom module import member as member\n```\n\nAlternatively, you can use `__all__` to declare a symbol as part of the module's\ninterface, as in:\n\n```python\n# __init__.py\nimport some_module\n\n__all__ = [\"some_module\"]\n```\n\n## Preview\nWhen [preview] is enabled (and certain simplifying assumptions\nare met), we analyze all import statements for a given module\nwhen determining whether an import is used, rather than simply\nthe last of these statements. This can result in both different and\nmore import statements being marked as unused.\n\nFor example, if a module consists of\n\n```python\nimport a\nimport a.b\n```\n\nthen both statements are marked as unused under [preview], whereas\nonly the second is marked as unused under stable behavior.\n\nAs another example, if a module consists of\n\n```python\nimport a.b\nimport a\n\na.b.foo()\n```\n\nthen a diagnostic will only be emitted for the first line under [preview],\nwhereas a diagnostic would only be emitted for the second line under\nstable behavior.\n\nNote that this behavior is somewhat subjective and is designed\nto conform to the developer's intuition rather than Python's actual\nexecution. To wit, the statement `import a.b` automatically executes\n`import a`, so in some sense `import a` is _always_ redundant\nin the presence of `import a.b`.\n\n\n## Fix safety\n\nFixes to remove unused imports are safe, except in `__init__.py` files.\n\nApplying fixes to `__init__.py` files is currently in preview. The fix offered depends on the\ntype of the unused import. Ruff will suggest a safe fix to export first-party imports with\neither a redundant alias or, if already present in the file, an `__all__` entry. If multiple\n`__all__` declarations are present, Ruff will not offer a fix. Ruff will suggest an unsafe fix\nto remove third-party and standard library imports -- the fix is unsafe because the module's\ninterface changes.\n\nSee [this FAQ section](https://docs.astral.sh/ruff/faq/#how-does-ruff-determine-which-of-my-imports-are-first-party-third-party-etc)\nfor more details on how Ruff\ndetermines whether an import is first or third-party.\n\n## Example\n\n```python\nimport numpy as np  # unused import\n\n\ndef area(radius):\n    return 3.14 * radius**2\n```\n\nUse instead:\n\n```python\ndef area(radius):\n    return 3.14 * radius**2\n```\n\nTo check the availability of a module, use `importlib.util.find_spec`:\n\n```python\nfrom importlib.util import find_spec\n\nif find_spec(\"numpy\") is not None:\n    print(\"numpy is installed\")\nelse:\n    print(\"numpy is not installed\")\n```\n\n## Options\n- `lint.ignore-init-module-imports`\n- `lint.pyflakes.allowed-unused-imports`\n\n## References\n- [Python documentation: `import`](https://docs.python.org/3/reference/simple_stmts.html#the-import-statement)\n- [Python documentation: `importlib.util.find_spec`](https://docs.python.org/3/library/importlib.html#importlib.util.find_spec)\n- [Typing documentation: interface conventions](https://typing.python.org/en/latest/spec/distributing.html#library-interface-public-and-private-symbols)\n\n[preview]: https://docs.astral.sh/ruff/preview/\n",
+  "preview": false,
+  "status": "Stable"
+}
+----- stderr -----

crates/ruff/tests/snapshots/integration_test__rule_f401_output_text.snap

@@ -0,0 +1,140 @@
+---
+source: crates/ruff/tests/integration_test.rs
+info:
+  program: ruff
+  args:
+    - rule
+    - F401
+    - "--output-format"
+    - text
+---
+success: true
+exit_code: 0
+----- stdout -----
+# unused-import (F401)
+
+Derived from the **Pyflakes** linter.
+
+Fix is sometimes available.
+
+## What it does
+Checks for unused imports.
+
+## Why is this bad?
+Unused imports add a performance overhead at runtime, and risk creating
+import cycles. They also increase the cognitive load of reading the code.
+
+If an import statement is used to check for the availability or existence
+of a module, consider using `importlib.util.find_spec` instead.
+
+If an import statement is used to re-export a symbol as part of a module's
+public interface, consider using a "redundant" import alias, which
+instructs Ruff (and other tools) to respect the re-export, and avoid
+marking it as unused, as in:
+
+```python
+from module import member as member
+```
+
+Alternatively, you can use `__all__` to declare a symbol as part of the module's
+interface, as in:
+
+```python
+# __init__.py
+import some_module
+
+__all__ = ["some_module"]
+```
+
+## Preview
+When [preview] is enabled (and certain simplifying assumptions
+are met), we analyze all import statements for a given module
+when determining whether an import is used, rather than simply
+the last of these statements. This can result in both different and
+more import statements being marked as unused.
+
+For example, if a module consists of
+
+```python
+import a
+import a.b
+```
+
+then both statements are marked as unused under [preview], whereas
+only the second is marked as unused under stable behavior.
+
+As another example, if a module consists of
+
+```python
+import a.b
+import a
+
+a.b.foo()
+```
+
+then a diagnostic will only be emitted for the first line under [preview],
+whereas a diagnostic would only be emitted for the second line under
+stable behavior.
+
+Note that this behavior is somewhat subjective and is designed
+to conform to the developer's intuition rather than Python's actual
+execution. To wit, the statement `import a.b` automatically executes
+`import a`, so in some sense `import a` is _always_ redundant
+in the presence of `import a.b`.
+
+
+## Fix safety
+
+Fixes to remove unused imports are safe, except in `__init__.py` files.
+
+Applying fixes to `__init__.py` files is currently in preview. The fix offered depends on the
+type of the unused import. Ruff will suggest a safe fix to export first-party imports with
+either a redundant alias or, if already present in the file, an `__all__` entry. If multiple
+`__all__` declarations are present, Ruff will not offer a fix. Ruff will suggest an unsafe fix
+to remove third-party and standard library imports -- the fix is unsafe because the module's
+interface changes.
+
+See [this FAQ section](https://docs.astral.sh/ruff/faq/#how-does-ruff-determine-which-of-my-imports-are-first-party-third-party-etc)
+for more details on how Ruff
+determines whether an import is first or third-party.
+
+## Example
+
+```python
+import numpy as np  # unused import
+
+
+def area(radius):
+    return 3.14 * radius**2
+```
+
+Use instead:
+
+```python
+def area(radius):
+    return 3.14 * radius**2
+```
+
+To check the availability of a module, use `importlib.util.find_spec`:
+
+```python
+from importlib.util import find_spec
+
+if find_spec("numpy") is not None:
+    print("numpy is installed")
+else:
+    print("numpy is not installed")
+```
+
+## Options
+- `lint.ignore-init-module-imports`
+- `lint.pyflakes.allowed-unused-imports`
+
+## References
+- [Python documentation: `import`](https://docs.python.org/3/reference/simple_stmts.html#the-import-statement)
+- [Python documentation: `importlib.util.find_spec`](https://docs.python.org/3/library/importlib.html#importlib.util.find_spec)
+- [Typing documentation: interface conventions](https://typing.python.org/en/latest/spec/distributing.html#library-interface-public-and-private-symbols)
+
+[preview]: https://docs.astral.sh/ruff/preview/
+
+----- stderr -----

crates/ruff_linter/src/codes.rs

@@ -5,6 +5,7 @@
 use std::fmt::Formatter;
 
 use ruff_db::diagnostic::SecondaryCode;
+use serde::Serialize;
 use strum_macros::EnumIter;
 
 use crate::registry::Linter;
@@ -74,7 +75,7 @@ impl serde::Serialize for NoqaCode {
     }
 }
 
-#[derive(Debug, Copy, Clone)]
+#[derive(Debug, Copy, Clone, Serialize)]
 pub enum RuleGroup {
     /// The rule is stable.
     Stable,

crates/ruff_linter/src/violation.rs

@@ -1,12 +1,14 @@
 use std::fmt::{Debug, Display};
 
+use serde::Serialize;
+
 use ruff_db::diagnostic::Diagnostic;
 use ruff_source_file::SourceFile;
 use ruff_text_size::TextRange;
 
 use crate::{codes::Rule, message::create_lint_diagnostic};
 
-#[derive(Debug, Copy, Clone)]
+#[derive(Debug, Copy, Clone, Serialize)]
 pub enum FixAvailability {
     Sometimes,
     Always,