Support markdown in extension mappings (#23218)

amyreese · web-flow · commit 8fc595aa6ba1 · 2026-02-11T10:36:05.000-08:00
diff --git a/crates/ruff/src/commands/analyze_graph.rs b/crates/ruff/src/commands/analyze_graph.rs
@@ -10,7 +10,7 @@ use ruff_graph::{Direction, ImportMap, ModuleDb, ModuleImports};
 use ruff_linter::package::PackageRoot;
 use ruff_linter::source_kind::SourceKind;
 use ruff_linter::{warn_user, warn_user_once};
-use ruff_python_ast::{PySourceType, SourceType};
+use ruff_python_ast::SourceType;
 use ruff_workspace::resolver::{ResolvedFile, match_exclusion, python_files_in_path};
 use rustc_hash::{FxBuildHasher, FxHashMap};
 use std::io::Write;
@@ -137,19 +137,16 @@ pub(crate) fn analyze_graph(
                 }
 
                 // Ignore non-Python files.
-                let source_type = match settings.analyze.extension.get(path) {
-                    None => match SourceType::from(&path) {
-                        SourceType::Python(source_type) => source_type,
-                        SourceType::Toml(_) => {
-                            debug!("Ignoring TOML file: {}", path.display());
-                            continue;
-                        }
-                        SourceType::Markdown => {
-                            debug!("Ignoring Markdown file: {}", path.display());
-                            continue;
-                        }
-                    },
-                    Some(language) => PySourceType::from(language),
+                let source_type = match settings.analyze.extension.get_source_type(path) {
+                    SourceType::Python(source_type) => source_type,
+                    SourceType::Toml(_) => {
+                        debug!("Ignoring TOML file: {}", path.display());
+                        continue;
+                    }
+                    SourceType::Markdown => {
+                        debug!("Ignoring Markdown file: {}", path.display());
+                        continue;
+                    }
                 };
 
                 // Convert to system paths.
diff --git a/crates/ruff/src/commands/format.rs b/crates/ruff/src/commands/format.rs
@@ -123,10 +123,7 @@ pub(crate) fn format(
                     let path = resolved_file.path();
                     let settings = resolver.resolve(path);
 
-                    let source_type = match settings.formatter.extension.get(path) {
-                        None => SourceType::from(path),
-                        Some(language) => SourceType::Python(PySourceType::from(language)),
-                    };
+                    let source_type = settings.formatter.extension.get_source_type(path);
                     if source_type.is_toml() {
                         // Ignore TOML files.
                         return None;
diff --git a/crates/ruff/src/commands/format_stdin.rs b/crates/ruff/src/commands/format_stdin.rs
@@ -5,7 +5,7 @@ use anyhow::Result;
 use log::error;
 
 use ruff_linter::source_kind::{SourceError, SourceKind};
-use ruff_python_ast::{PySourceType, SourceType};
+use ruff_python_ast::SourceType;
 use ruff_workspace::FormatterSettings;
 use ruff_workspace::resolver::{PyprojectConfig, Resolver, match_exclusion, python_file_at_path};
 
@@ -51,18 +51,15 @@ pub(crate) fn format_stdin(
     let path = cli.stdin_filename.as_deref();
     let settings = &resolver.base_settings().formatter;
 
-    let source_type = match path.and_then(|path| settings.extension.get(path)) {
-        None => match path.map(SourceType::from).unwrap_or_default() {
-            source_type @ (SourceType::Python(_) | SourceType::Markdown) => source_type,
-            SourceType::Toml(_) => {
-                if mode.is_write() {
-                    parrot_stdin()?;
-                }
-                return Ok(ExitStatus::Success);
-            }
-        },
-        Some(language) => SourceType::Python(PySourceType::from(language)),
-    };
+    let source_type = path
+        .map(|path| settings.extension.get_source_type(path))
+        .unwrap_or_default();
+    if source_type.is_toml() {
+        if mode.is_write() {
+            parrot_stdin()?;
+        }
+        return Ok(ExitStatus::Success);
+    }
 
     // Format the file.
     match format_source_code(path, cli.range, settings, source_type, mode) {
diff --git a/crates/ruff/src/diagnostics.rs b/crates/ruff/src/diagnostics.rs
@@ -20,7 +20,7 @@ use ruff_linter::settings::{LinterSettings, flags};
 use ruff_linter::source_kind::{SourceError, SourceKind};
 use ruff_linter::{IOError, Violation, fs};
 use ruff_notebook::{NotebookError, NotebookIndex};
-use ruff_python_ast::{PySourceType, SourceType, TomlSourceType};
+use ruff_python_ast::{SourceType, TomlSourceType};
 use ruff_source_file::SourceFileBuilder;
 use ruff_text_size::TextRange;
 use ruff_workspace::Settings;
@@ -208,35 +208,31 @@ pub(crate) fn lint_path(
 
     debug!("Checking: {}", path.display());
 
-    let source_type = match settings.extension.get(path).map(PySourceType::from) {
-        Some(source_type) => source_type,
-        None => match SourceType::from(path) {
-            SourceType::Toml(TomlSourceType::Pyproject) => {
-                let diagnostics = if settings
-                    .rules
-                    .iter_enabled()
-                    .any(|rule_code| rule_code.lint_source().is_pyproject_toml())
-                {
-                    let contents = match std::fs::read_to_string(path).map_err(SourceError::from) {
-                        Ok(contents) => contents,
-                        Err(err) => {
-                            return Ok(Diagnostics::from_source_error(&err, Some(path), settings));
-                        }
-                    };
-                    let source_file =
-                        SourceFileBuilder::new(path.to_string_lossy(), contents).finish();
-                    lint_pyproject_toml(&source_file, settings)
-                } else {
-                    vec![]
+    let source_type = match settings.extension.get_source_type(path) {
+        SourceType::Toml(TomlSourceType::Pyproject) => {
+            let diagnostics = if settings
+                .rules
+                .iter_enabled()
+                .any(|rule_code| rule_code.lint_source().is_pyproject_toml())
+            {
+                let contents = match std::fs::read_to_string(path).map_err(SourceError::from) {
+                    Ok(contents) => contents,
+                    Err(err) => {
+                        return Ok(Diagnostics::from_source_error(&err, Some(path), settings));
+                    }
                 };
-                return Ok(Diagnostics {
-                    inner: diagnostics,
-                    ..Diagnostics::default()
-                });
-            }
-            SourceType::Toml(_) | SourceType::Markdown => return Ok(Diagnostics::default()),
-            SourceType::Python(source_type) => source_type,
-        },
+                let source_file = SourceFileBuilder::new(path.to_string_lossy(), contents).finish();
+                lint_pyproject_toml(&source_file, settings)
+            } else {
+                vec![]
+            };
+            return Ok(Diagnostics {
+                inner: diagnostics,
+                ..Diagnostics::default()
+            });
+        }
+        SourceType::Toml(_) | SourceType::Markdown => return Ok(Diagnostics::default()),
+        SourceType::Python(source_type) => source_type,
     };
 
     // Extract the sources from the file.
@@ -356,42 +352,37 @@ pub(crate) fn lint_stdin(
     fix_mode: flags::FixMode,
 ) -> Result<Diagnostics> {
     let (source_type, py_source_type) = match path
-        .and_then(|path| settings.linter.extension.get(path))
+        .map(|path| settings.linter.extension.get_source_type(path))
+        .unwrap_or_default()
     {
-        None => match path.map(SourceType::from).unwrap_or_default() {
-            SourceType::Toml(source_type) if source_type.is_pyproject() => {
-                if !settings
-                    .linter
-                    .rules
-                    .iter_enabled()
-                    .any(|rule_code| rule_code.lint_source().is_pyproject_toml())
-                {
-                    return Ok(Diagnostics::default());
-                }
+        SourceType::Toml(source_type) if source_type.is_pyproject() => {
+            if !settings
+                .linter
+                .rules
+                .iter_enabled()
+                .any(|rule_code| rule_code.lint_source().is_pyproject_toml())
+            {
+                return Ok(Diagnostics::default());
+            }
 
-                let path = path.unwrap();
-                let source_file =
-                    SourceFileBuilder::new(path.to_string_lossy(), contents.clone()).finish();
+            let path = path.unwrap();
+            let source_file =
+                SourceFileBuilder::new(path.to_string_lossy(), contents.clone()).finish();
 
-                match fix_mode {
-                    flags::FixMode::Diff | flags::FixMode::Generate => {}
-                    flags::FixMode::Apply => write!(&mut io::stdout().lock(), "{contents}")?,
-                }
-
-                return Ok(Diagnostics {
-                    inner: lint_pyproject_toml(&source_file, &settings.linter),
-                    fixed: FixMap::from_iter([(fs::relativize_path(path), FixTable::default())]),
-                    notebook_indexes: FxHashMap::default(),
-                });
+            match fix_mode {
+                flags::FixMode::Diff | flags::FixMode::Generate => {}
+                flags::FixMode::Apply => write!(&mut io::stdout().lock(), "{contents}")?,
             }
 
-            SourceType::Toml(_) | SourceType::Markdown => return Ok(Diagnostics::default()),
-            source_type @ SourceType::Python(py_source_type) => (source_type, py_source_type),
-        },
-        Some(language) => {
-            let py_source_type = PySourceType::from(language);
-            (SourceType::Python(py_source_type), py_source_type)
+            return Ok(Diagnostics {
+                inner: lint_pyproject_toml(&source_file, &settings.linter),
+                fixed: FixMap::from_iter([(fs::relativize_path(path), FixTable::default())]),
+                notebook_indexes: FxHashMap::default(),
+            });
         }
+
+        SourceType::Toml(_) | SourceType::Markdown => return Ok(Diagnostics::default()),
+        source_type @ SourceType::Python(py_source_type) => (source_type, py_source_type),
     };
 
     // Extract the sources from the file.
diff --git a/crates/ruff_linter/src/settings/types.rs b/crates/ruff_linter/src/settings/types.rs
@@ -16,7 +16,7 @@ use strum_macros::EnumIter;
 
 use ruff_cache::{CacheKey, CacheKeyHasher};
 use ruff_macros::CacheKey;
-use ruff_python_ast::{self as ast, PySourceType};
+use ruff_python_ast::{self as ast, PySourceType, SourceType};
 
 use crate::Applicability;
 use crate::registry::RuleSet;
@@ -428,6 +428,7 @@ pub enum Language {
     Python,
     Pyi,
     Ipynb,
+    Markdown,
 }
 
 impl FromStr for Language {
@@ -438,19 +439,21 @@ impl FromStr for Language {
             "python" => Ok(Self::Python),
             "pyi" => Ok(Self::Pyi),
             "ipynb" => Ok(Self::Ipynb),
+            "md" => Ok(Self::Markdown),
             _ => {
                 bail!("Unrecognized language: `{s}`. Expected one of `python`, `pyi`, or `ipynb`.")
             }
         }
     }
 }
 
-impl From<Language> for PySourceType {
+impl From<Language> for SourceType {
     fn from(value: Language) -> Self {
         match value {
-            Language::Python => Self::Python,
-            Language::Ipynb => Self::Ipynb,
-            Language::Pyi => Self::Stub,
+            Language::Python => Self::Python(PySourceType::Python),
+            Language::Ipynb => Self::Python(PySourceType::Ipynb),
+            Language::Pyi => Self::Python(PySourceType::Stub),
+            Language::Markdown => Self::Markdown,
         }
     }
 }
@@ -505,6 +508,22 @@ impl ExtensionMapping {
     pub fn get_extension(&self, ext: &str) -> Option<Language> {
         self.0.get(ext).copied()
     }
+
+    /// Return a mapped [`SourceType`] for a given path.
+    pub fn get_source_type(&self, path: &Path) -> SourceType {
+        match self.get(path) {
+            None => SourceType::from(path),
+            Some(language) => SourceType::from(language),
+        }
+    }
+
+    /// Return a mapped [`SourceType`] for a given file extension.
+    pub fn get_source_type_by_extension(&self, ext: &str) -> SourceType {
+        match self.get_extension(ext) {
+            None => SourceType::from_extension(ext),
+            Some(language) => SourceType::from(language),
+        }
+    }
 }
 
 impl From<FxHashMap<String, Language>> for ExtensionMapping {
diff --git a/crates/ruff_markdown/src/lib.rs b/crates/ruff_markdown/src/lib.rs
@@ -1,7 +1,7 @@
 use std::{path::Path, sync::LazyLock};
 
 use regex::Regex;
-use ruff_python_ast::PySourceType;
+use ruff_python_ast::{PySourceType, SourceType};
 use ruff_python_formatter::format_module_source;
 use ruff_python_trivia::textwrap::{dedent, indent};
 use ruff_source_file::{Line, UniversalNewlines};
@@ -91,9 +91,10 @@ pub fn format_code_blocks(
 
                 // Maybe python, try formatting it
                 let language = language.to_ascii_lowercase();
-                let py_source_type = match settings.extension.get_extension(&language) {
-                    None => PySourceType::from_extension(&language),
-                    Some(language) => PySourceType::from(language),
+                let SourceType::Python(py_source_type) =
+                    settings.extension.get_source_type_by_extension(&language)
+                else {
+                    break;
                 };
 
                 let end = code_line.start();
diff --git a/crates/ruff_python_ast/src/lib.rs b/crates/ruff_python_ast/src/lib.rs
@@ -47,6 +47,16 @@ pub enum SourceType {
     Markdown,
 }
 
+impl SourceType {
+    pub fn from_extension(ext: &str) -> Self {
+        match ext {
+            "toml" => Self::Toml(TomlSourceType::Unrecognized),
+            "md" | "qmd" => Self::Markdown,
+            _ => Self::Python(PySourceType::from_extension(ext)),
+        }
+    }
+}
+
 impl Default for SourceType {
     fn default() -> Self {
         Self::Python(PySourceType::Python)
@@ -59,11 +69,12 @@ impl<P: AsRef<Path>> From<P> for SourceType {
             Some(filename) if filename == "pyproject.toml" => Self::Toml(TomlSourceType::Pyproject),
             Some(filename) if filename == "Pipfile" => Self::Toml(TomlSourceType::Pipfile),
             Some(filename) if filename == "poetry.lock" => Self::Toml(TomlSourceType::Poetry),
-            _ => match path.as_ref().extension() {
-                Some(ext) if ext == "toml" => Self::Toml(TomlSourceType::Unrecognized),
-                Some(ext) if ext == "md" || ext == "qmd" => Self::Markdown,
-                _ => Self::Python(PySourceType::from(path)),
-            },
+            _ => Self::from_extension(
+                path.as_ref()
+                    .extension()
+                    .and_then(OsStr::to_str)
+                    .unwrap_or(""),
+            ),
         }
     }
 }
