Consider VS Code cell metadata to determine valid code cells (#12864)

## Summary

This PR adds support for VS Code specific cell metadata to consider when
collecting valid code cells.

For context, Ruff only runs on valid code cells. These are the code
cells that doesn't contain cell magics. Previously, Ruff only used the
notebook's metadata to determine whether it's a Python notebook. But, in
VS Code, a notebook's preferred language might be Python but it could
still contain code cells for other languages. This can be determined
with the `metadata.vscode.languageId` field.

### References:
* https://code.visualstudio.com/docs/languages/identifiers
* e6c009a3d4/extensions/ipynb/src/serializers.ts (L104-L107)
*
e6c009a3d4/extensions/ipynb/src/serializers.ts (L117-L122)

This brings us one step closer to fixing #12281.

## Test Plan

Add test cases for `is_valid_python_code_cell` and an integration test
case which showcase running it end to end. The test notebook contains a
JavaScript code cell and a Python code cell.

crates/ruff_notebook/src/cell.rs

@@ -6,6 +6,7 @@ use itertools::Itertools;
 use ruff_text_size::{TextRange, TextSize};
 
 use crate::schema::{Cell, SourceValue};
+use crate::CellMetadata;
 
 impl fmt::Display for SourceValue {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
@@ -35,7 +36,7 @@ impl Cell {
         matches!(self, Cell::Code(_))
     }
 
-    pub fn metadata(&self) -> &serde_json::Value {
+    pub fn metadata(&self) -> &CellMetadata {
         match self {
             Cell::Code(cell) => &cell.metadata,
             Cell::Markdown(cell) => &cell.metadata,
@@ -54,11 +55,21 @@ impl Cell {
 
     /// Return `true` if it's a valid code cell.
     ///
-    /// A valid code cell is a cell where the cell type is [`Cell::Code`] and the
-    /// source doesn't contain a cell magic.
-    pub(crate) fn is_valid_code_cell(&self) -> bool {
+    /// A valid code cell is a cell where:
+    /// 1. The cell type is [`Cell::Code`]
+    /// 2. The source doesn't contain a cell magic
+    /// 3. If the language id is set, it should be `python`
+    pub(crate) fn is_valid_python_code_cell(&self) -> bool {
         let source = match self {
-            Cell::Code(cell) => &cell.source,
+            Cell::Code(cell)
+                if cell
+                    .metadata
+                    .vscode
+                    .as_ref()
+                    .map_or(true, |vscode| vscode.language_id == "python") =>
+            {
+                &cell.source
+            }
             _ => return false,
         };
         // Ignore cells containing cell magic as they act on the entire cell

crates/ruff_notebook/src/notebook.rs

@@ -19,7 +19,7 @@ use ruff_text_size::TextSize;
 use crate::cell::CellOffsets;
 use crate::index::NotebookIndex;
 use crate::schema::{Cell, RawNotebook, SortAlphabetically, SourceValue};
-use crate::{schema, RawNotebookMetadata};
+use crate::{schema, CellMetadata, RawNotebookMetadata};
 
 /// Run round-trip source code generation on a given Jupyter notebook file path.
 pub fn round_trip(path: &Path) -> anyhow::Result<String> {
@@ -131,7 +131,7 @@ impl Notebook {
             .cells
             .iter()
             .enumerate()
-            .filter(|(_, cell)| cell.is_valid_code_cell())
+            .filter(|(_, cell)| cell.is_valid_python_code_cell())
             .map(|(cell_index, _)| u32::try_from(cell_index).unwrap())
             .collect::<Vec<_>>();
 
@@ -205,16 +205,14 @@ impl Notebook {
         })
     }
 
-    /// Creates an empty notebook.
-    ///
-    ///
+    /// Creates an empty notebook with a single code cell.
     pub fn empty() -> Self {
         Self::from_raw_notebook(
             RawNotebook {
                 cells: vec![schema::Cell::Code(schema::CodeCell {
                     execution_count: None,
                     id: None,
-                    metadata: serde_json::Value::default(),
+                    metadata: CellMetadata::default(),
                     outputs: vec![],
                     source: schema::SourceValue::String(String::default()),
                 })],
@@ -507,7 +505,9 @@ mod tests {
     #[test_case("automagic_before_code", false)]
     #[test_case("automagic_after_code", true)]
     #[test_case("unicode_magic_gh9145", true)]
-    fn test_is_valid_code_cell(cell: &str, expected: bool) -> Result<()> {
+    #[test_case("vscode_language_id_python", true)]
+    #[test_case("vscode_language_id_javascript", false)]
+    fn test_is_valid_python_code_cell(cell: &str, expected: bool) -> Result<()> {
         /// Read a Jupyter cell from the `resources/test/fixtures/jupyter/cell` directory.
         fn read_jupyter_cell(path: impl AsRef<Path>) -> Result<Cell> {
             let path = notebook_path("cell").join(path);
@@ -516,7 +516,7 @@ mod tests {
         }
 
         assert_eq!(
-            read_jupyter_cell(format!("{cell}.json"))?.is_valid_code_cell(),
+            read_jupyter_cell(format!("{cell}.json"))?.is_valid_python_code_cell(),
             expected
         );
         Ok(())
@@ -596,4 +596,12 @@ print("after empty cells")
         );
         Ok(())
     }
+
+    #[test]
+    fn round_trip() {
+        let path = notebook_path("vscode_language_id.ipynb");
+        let expected = std::fs::read_to_string(&path).unwrap();
+        let actual = super::round_trip(&path).unwrap();
+        assert_eq!(actual, expected);
+    }
 }

crates/ruff_notebook/src/schema.rs

@@ -18,7 +18,7 @@
 //!   a code cell or not without looking at the `cell_type` property, which
 //!   would require a custom serializer.
 
-use std::collections::BTreeMap;
+use std::collections::{BTreeMap, HashMap};
 
 use serde::{Deserialize, Serialize};
 use serde_json::Value;
@@ -122,7 +122,7 @@ pub struct RawCell {
     /// <https://youtrack.jetbrains.com/issue/PY-59438/Jupyter-notebooks-created-with-PyCharm-are-missing-the-id-field-in-cells-in-the-.ipynb-json>
     pub id: Option<String>,
     /// Cell-level metadata.
-    pub metadata: Value,
+    pub metadata: CellMetadata,
     pub source: SourceValue,
 }
 
@@ -137,7 +137,7 @@ pub struct MarkdownCell {
     /// <https://youtrack.jetbrains.com/issue/PY-59438/Jupyter-notebooks-created-with-PyCharm-are-missing-the-id-field-in-cells-in-the-.ipynb-json>
     pub id: Option<String>,
     /// Cell-level metadata.
-    pub metadata: Value,
+    pub metadata: CellMetadata,
     pub source: SourceValue,
 }
 
@@ -153,12 +153,36 @@ pub struct CodeCell {
     #[serde(skip_serializing_if = "Option::is_none")]
     pub id: Option<String>,
     /// Cell-level metadata.
-    pub metadata: Value,
+    pub metadata: CellMetadata,
     /// Execution, display, or stream outputs.
     pub outputs: Vec<Value>,
     pub source: SourceValue,
 }
 
+/// Cell-level metadata.
+#[skip_serializing_none]
+#[derive(Clone, Debug, Default, Serialize, Deserialize, PartialEq)]
+pub struct CellMetadata {
+    /// VS Code specific cell metadata.
+    ///
+    /// This is [`Some`] only if the cell's preferred language is different from the notebook's
+    /// preferred language.
+    /// <https://github.com/microsoft/vscode/blob/e6c009a3d4ee60f352212b978934f52c4689fbd9/extensions/ipynb/src/serializers.ts#L117-L122>
+    pub vscode: Option<CodeCellMetadataVSCode>,
+    /// Catch-all for metadata that isn't required by Ruff.
+    #[serde(flatten)]
+    pub extra: HashMap<String, Value>,
+}
+
+/// VS Code specific cell metadata.
+/// <https://github.com/microsoft/vscode/blob/e6c009a3d4ee60f352212b978934f52c4689fbd9/extensions/ipynb/src/serializers.ts#L104-L107>
+#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
+#[serde(rename_all = "camelCase")]
+pub struct CodeCellMetadataVSCode {
+    /// <https://code.visualstudio.com/docs/languages/identifiers>
+    pub language_id: String,
+}
+
 /// Notebook root-level metadata.
 #[skip_serializing_none]
 #[derive(Clone, Debug, Serialize, Deserialize, PartialEq, Default)]