Code at the speed of thought – Zed is a high-performance, multiplayer code editor from the creators of Atom and Tree-sitter.
Add JSONL and NDJSON support to tabular preview (#64471)
Ansh Dawdad528c665e1a5
diff --git a/Cargo.lock b/Cargo.lockindex 9e727ba650f..26efd5f5e47 100644--- a/Cargo.lock+++ b/Cargo.lock@@ -18110,6 +18110,7 @@ dependencies = ["editor","fuzzy","gpui",+ "indexmap 2.14.0","log","picker","project",diff --git a/assets/keymaps/default-linux.json b/assets/keymaps/default-linux.jsonindex 89fb803d58b..fcdc8f7a9c6 100644--- a/assets/keymaps/default-linux.json+++ b/assets/keymaps/default-linux.json@@ -617,7 +617,7 @@},},{- "context": "Editor && (extension == csv || extension == tsv || extension == ssv || extension == psv)",+ "context": "Editor && (extension == csv || extension == tsv || extension == ssv || extension == psv || extension == jsonl || extension == ndjson)","use_key_equivalents": true,"bindings": {"ctrl-k v": "tabular_data::OpenPreviewToTheSide",diff --git a/assets/keymaps/default-macos.json b/assets/keymaps/default-macos.jsonindex 2226cb43eb0..1e6374ef661 100644--- a/assets/keymaps/default-macos.json+++ b/assets/keymaps/default-macos.json@@ -656,7 +656,7 @@},},{- "context": "Editor && (extension == csv || extension == tsv || extension == ssv || extension == psv)",+ "context": "Editor && (extension == csv || extension == tsv || extension == ssv || extension == psv || extension == jsonl || extension == ndjson)","use_key_equivalents": true,"bindings": {"cmd-k v": "tabular_data::OpenPreviewToTheSide",diff --git a/assets/keymaps/default-windows.json b/assets/keymaps/default-windows.jsonindex 56aa6d3a508..c9c5f90af42 100644--- a/assets/keymaps/default-windows.json+++ b/assets/keymaps/default-windows.json@@ -615,7 +615,7 @@},},{- "context": "Editor && (extension == csv || extension == tsv || extension == ssv || extension == psv)",+ "context": "Editor && (extension == csv || extension == tsv || extension == ssv || extension == psv || extension == jsonl || extension == ndjson)","use_key_equivalents": true,"bindings": {"ctrl-k v": "tabular_data::OpenPreviewToTheSide",diff --git a/crates/tabular_data_preview/Cargo.toml b/crates/tabular_data_preview/Cargo.tomlindex dfa12397019..6fa37648b52 100644--- a/crates/tabular_data_preview/Cargo.toml+++ b/crates/tabular_data_preview/Cargo.toml@@ -17,13 +17,14 @@ picker.workspace = trueui.workspace = trueworkspace.workspace = truelog.workspace = true+indexmap.workspace = true+serde_json.workspace = truetext.workspace = true[dev-dependencies]gpui = { workspace = true, features = ["test-support"] }project = { workspace = true, features = ["test-support"] }proptest.workspace = true-serde_json.workspace = trueutil.workspace = trueworkspace = { workspace = true, features = ["test-support"] }diff --git a/crates/tabular_data_preview/src/parser.rs b/crates/tabular_data_preview/src/parser.rsindex 791d311f663..9c691d03b36 100644--- a/crates/tabular_data_preview/src/parser.rs+++ b/crates/tabular_data_preview/src/parser.rs@@ -1,4 +1,7 @@-use std::sync::Arc;+use indexmap::{IndexMap, IndexSet};++use anyhow::Context as _;+use serde_json::value::RawValue;use crate::{TabularDataPreviewPane,@@ -19,12 +22,13 @@ pub(crate) struct EditorState {pub _subscription: Subscription,}-#[derive(Clone, Copy)]+#[derive(Clone, Copy, Debug, PartialEq, Eq)]pub(crate) enum TabularFormat {Csv,Tsv,Psv,Ssv,+ JsonLines,}const TABULAR_FORMATS: &[(&str, TabularFormat)] = &[@@ -32,6 +36,8 @@ const TABULAR_FORMATS: &[(&str, TabularFormat)] = &[("tsv", TabularFormat::Tsv),("psv", TabularFormat::Psv),("ssv", TabularFormat::Ssv),+ ("jsonl", TabularFormat::JsonLines),+ ("ndjson", TabularFormat::JsonLines),];impl TabularFormat {@@ -46,13 +52,15 @@ impl TabularFormat {.map(|(_, format)| *format)}- fn delimiter(self) -> char {- match self {- TabularFormat::Csv => ',',- TabularFormat::Tsv => '\t',- TabularFormat::Psv => '|',- TabularFormat::Ssv => ';',- }+ fn parse(self, buffer_snapshot: &BufferSnapshot) -> anyhow::Result<TableLikeContent> {+ let delimiter = match self {+ Self::Csv => ',',+ Self::Tsv => '\t',+ Self::Psv => '|',+ Self::Ssv => ';',+ Self::JsonLines => return from_json_lines(buffer_snapshot),+ };+ Ok(from_buffer_with_delimiter(buffer_snapshot, delimiter))}}@@ -101,7 +109,7 @@ impl TabularDataPreviewPane {}}- let (buffer_snapshot, delimiter) = view.update(cx, |_, cx| {+ let (buffer_snapshot, format) = view.update(cx, |_, cx| {let buffer_ref = editor.read(cx).buffer()@@ -111,26 +119,30 @@ impl TabularDataPreviewPane {let extension = editor_file_extension(&editor, cx);- let delimiter = extension+ let format = extension.and_then(TabularFormat::from_extension)- .map(TabularFormat::delimiter).unwrap_or_else(|| {log::warn!(- "unrecognized tabular data extension {extension:?}, defaulting to comma delimiter"+ "unrecognized tabular data extension {extension:?}, defaulting to CSV");- ','+ TabularFormat::Csv});- (buffer_ref, delimiter)+ (buffer_ref, format)})?;let Some(buffer_snapshot) = buffer_snapshot else {+ view.update(cx, |view, cx| {+ view.is_parsing = false;+ view.parse_error = Some("Preview requires a single file".into());+ cx.notify();+ })?;return Ok(());};let instant = Instant::now();let parsed_contents = cx- .background_spawn(async move { from_buffer_with_delimiter(&buffer_snapshot, delimiter) })+ .background_spawn(async move { format.parse(&buffer_snapshot) }).await;let parse_duration = instant.elapsed();let parse_end_time: Instant = Instant::now();@@ -140,13 +152,24 @@ impl TabularDataPreviewPane {.timings.insert("Parsing", (parse_duration, Instant::now()));- log::debug!("Parsed {} rows", parsed_contents.rows.len());- view.engine.contents = Arc::new(parsed_contents);- view.engine.calculate_available_filters();- view.sync_column_widths(cx);view.last_parse_end_time = Some(parse_end_time);-view.is_parsing = false;+ let parsed_contents = match parsed_contents {+ Ok(contents) => contents,+ Err(error) => {+ view.parse_error = Some(format!("{error:#}").into());+ view.filter_sort_task = None;+ cx.notify();+ return;+ }+ };++ log::debug!("Parsed {} rows", parsed_contents.rows.len());+ view.parse_error = None;+ view.engine.set_contents(parsed_contents);+ view.list_state+ .reset_with_uniform_height(0, view.row_height);+ view.sync_column_widths(cx);view.apply_filter_sort(cx);cx.notify();})@@ -154,6 +177,98 @@ impl TabularDataPreviewPane {}}+fn from_json_lines(buffer_snapshot: &BufferSnapshot) -> anyhow::Result<TableLikeContent> {+ let text = buffer_snapshot.text();+ let mut records = Vec::new();+ let mut columns = IndexSet::new();+ let mut line_numbers = Vec::new();++ for (line_index, line) in text.lines().enumerate() {+ // Ignore blank lines, but keep physical line numbers for the source gutter.+ if line.trim().is_empty() {+ continue;+ }+ let record: IndexMap<String, &RawValue> =+ serde_json::from_str(line).with_context(|| {+ format!(+ "Cannot preview JSONL line {}: expected a JSON object",+ line_index + 1+ )+ })?;+ columns.extend(record.keys().cloned());+ records.push(record);+ line_numbers.push(LineNumber::Line(line_index + 1));+ }++ let number_of_cols = columns.len();+ let headers = TableRow::from_vec(+ columns+ .iter()+ .map(|name| TableCell::Generated(name.clone().into()))+ .collect(),+ number_of_cols,+ );+ let rows = records+ .into_iter()+ .map(|record| {+ let cells = columns+ .iter()+ .map(|name| {+ let Some(value) = record.get(name) else {+ return Ok(TableCell::Virtual);+ };+ let raw = value.get();+ // RawValue borrows the original text, so its span stays exact even+ // for repeated values, escaped strings, and large numbers.+ let start = (raw.as_ptr() as usize)+ .checked_sub(text.as_ptr() as usize)+ .context("JSON value is outside the source buffer")?;+ Ok(TableCell::from_buffer_position(+ compact_json(raw).into(),+ start,+ start + raw.len(),+ buffer_snapshot,+ ))+ })+ .collect::<anyhow::Result<Vec<_>>>()?;+ Ok(TableRow::from_vec(cells, number_of_cols))+ })+ .collect::<anyhow::Result<Vec<_>>>()?;++ Ok(TableLikeContent {+ headers,+ rows,+ line_numbers,+ number_of_cols,+ })+}++fn compact_json(raw: &str) -> String {+ // Reserializing through Value can round numbers. Remove only insignificant+ // whitespace from the already validated JSON instead.+ let mut compact = String::with_capacity(raw.len());+ let mut in_string = false;+ let mut escaped = false;+ for character in raw.chars() {+ if in_string {+ compact.push(character);+ if escaped {+ escaped = false;+ } else if character == '\\' {+ escaped = true;+ } else if character == '"' {+ in_string = false;+ }+ } else if character == '"' {+ in_string = true;+ compact.push(character);+ } else if !matches!(character, ' ' | '\t' | '\r' | '\n') {+ compact.push(character);+ }+ }+ compact+}+pub fn from_buffer_with_delimiter(buffer_snapshot: &BufferSnapshot,delimiter: char,@@ -383,6 +498,201 @@ fn create_table_row(#[cfg(test)]mod tests {use super::*;+ use text::{Buffer, BufferId, ReplicaId, ToOffset};++ fn snapshot(text: &str) -> anyhow::Result<BufferSnapshot> {+ let buffer_id = BufferId::new(1).context("invalid test buffer ID")?;+ Ok(Buffer::new(ReplicaId::LOCAL, buffer_id, text.to_owned())+ .snapshot()+ .clone())+ }++ fn values(row: &TableRow<TableCell>) -> Vec<Option<&str>> {+ row.as_slice()+ .iter()+ .map(|cell| cell.display_value().map(|value| value.as_str()))+ .collect()+ }++ #[test]+ fn test_json_lines_columns_and_values() -> anyhow::Result<()> {+ let input = concat!(+ "{\"b\":null,\"a\":\"null\",\"nested\":{ \"items\": [1, true] }}\n",+ "{\"b\":\"\",\"late\":123456789012345678901234567890}\n",+ "{}"+ );+ let parsed = TabularFormat::JsonLines.parse(&snapshot(input)?)?;+ assert_eq!(+ values(&parsed.headers),+ vec![Some("b"), Some("a"), Some("nested"), Some("late")]+ );+ assert_eq!(parsed.rows.len(), 3);+ let rows: Vec<_> = parsed.rows.iter().map(values).collect();+ assert_eq!(+ rows,+ vec![+ vec![+ Some("null"),+ Some(r#""null""#),+ Some(r#"{"items":[1,true]}"#),+ None+ ],+ vec![+ Some(r#""""#),+ None,+ None,+ Some("123456789012345678901234567890")+ ],+ vec![None, None, None, None],+ ]+ );+ Ok(())+ }++ #[test]+ fn test_json_lines_columns_follow_first_seen_key_order() -> anyhow::Result<()> {+ let input = concat!(+ "{}\n",+ "{\"id\":2,\"name\":\"Grace\",\"active\":true}\n",+ "{\"name\":\"Ada\",\"tags\":[],\"id\":1,\"details\":{}}\n",+ "{\"details\":{},\"active\":false,\"extra\":null}\n"+ );+ let parsed = from_json_lines(&snapshot(input)?)?;+ assert_eq!(+ values(&parsed.headers),+ vec![+ Some("id"),+ Some("name"),+ Some("active"),+ Some("tags"),+ Some("details"),+ Some("extra")+ ]+ );+ assert_eq!(+ values(parsed.rows.get(2).context("missing record")?),+ vec![+ Some("1"),+ Some(r#""Ada""#),+ None,+ Some("[]"),+ Some("{}"),+ None+ ]+ );+ Ok(())+ }++ #[test]+ fn test_json_lines_source_spans_and_line_numbers() -> anyhow::Result<()> {+ let input =+ "\r\n{\"é\": \"🦀\", \"same\": \"🦀\"}\r\n \t\r\n{\"é\": 1.234567890123456789e100}\n";+ let snapshot = snapshot(input)?;+ let parsed = from_json_lines(&snapshot)?;+ let normalized_input = snapshot.text();+ assert!(matches!(+ parsed.line_numbers.as_slice(),+ [LineNumber::Line(2), LineNumber::Line(4)]+ ));+ assert_eq!(values(&parsed.headers), vec![Some("é"), Some("same")]);+ let first_row = parsed.rows.first().context("missing first row")?;+ for (cell, expected_start) in first_row.as_slice().iter().zip([+ normalized_input+ .find("\"🦀\"")+ .context("missing first value")?,+ normalized_input+ .rfind("\"🦀\"")+ .context("missing second value")?,+ ]) {+ let TableCell::Real { position, .. } = cell else {+ anyhow::bail!("expected a source-backed cell");+ };+ assert_eq!(position.start.to_offset(&snapshot), expected_start);+ assert_eq!(+ position.end.to_offset(&snapshot),+ expected_start + "\"🦀\"".len()+ );+ }+ assert_eq!(+ values(parsed.rows.last().context("missing last row")?),+ vec![Some("1.234567890123456789e100"), None]+ );+ Ok(())+ }++ #[test]+ fn test_json_lines_compact_values_preserve_strings_and_numbers() -> anyhow::Result<()> {+ let input = r#"{"value": { "text": "a b\t\"c\\", "numbers": [ -0, 1e999, 123456789012345678901234567890 ] }}"#;+ let parsed = from_json_lines(&snapshot(input)?)?;+ assert_eq!(+ values(parsed.rows.first().context("missing row")?),+ vec![Some(+ r#"{"text":"a b\t\"c\\","numbers":[-0,1e999,123456789012345678901234567890]}"#+ )]+ );+ Ok(())+ }++ #[test]+ fn test_json_lines_empty_input_and_empty_objects() -> anyhow::Result<()> {+ for input in ["", "\n \t\r\n"] {+ let parsed = from_json_lines(&snapshot(input)?)?;+ assert!(parsed.rows.is_empty());+ assert_eq!(parsed.number_of_cols, 0);+ }+ let parsed = from_json_lines(&snapshot("{}\n{}\n")?)?;+ assert_eq!(parsed.number_of_cols, 0);+ assert_eq!(parsed.rows.len(), 2);+ assert!(parsed.rows.iter().all(|row| row.cols() == 0));+ Ok(())+ }++ #[test]+ fn test_json_lines_errors_identify_the_source_line() -> anyhow::Result<()> {+ for invalid in [+ "{",+ "{\"a\":}",+ "{} trailing",+ "{} {}",+ "[]",+ "null",+ "true",+ "42",+ "\"text\"",+ ] {+ let input = format!("{{}}\n\n{invalid}\n{{}}\n");+ let result = from_json_lines(&snapshot(&input)?);+ let Err(error) = result else {+ anyhow::bail!("accepted invalid record: {invalid}");+ };+ assert!(error.to_string().contains("line 3"), "{error:#}");+ }+ Ok(())+ }++ #[test]+ fn test_format_dispatch() -> anyhow::Result<()> {+ for extension in ["jsonl", "ndjson", "JSONL", "nDjSoN"] {+ let format = TabularFormat::from_extension(extension).context("format not detected")?;+ assert_eq!(format, TabularFormat::JsonLines);+ assert_eq!(+ format.parse(&snapshot("{\"name\":\"Ada\"}")?)?.rows.len(),+ 1+ );+ }+ assert!(TabularFormat::from_extension("json").is_none());+ for (extension, delimiter) in [("csv", ','), ("tsv", '\t'), ("psv", '|'), ("ssv", ';')] {+ let input = format!("name{delimiter}age\nAda{delimiter}36");+ let format = TabularFormat::from_extension(extension).context("format not detected")?;+ let parsed = format.parse(&snapshot(&input)?)?;+ assert_eq!(values(&parsed.headers), vec![Some("name"), Some("age")]);+ assert_eq!(+ values(parsed.rows.first().context("missing row")?),+ vec![Some("Ada"), Some("36")]+ );+ }+ Ok(())+ }#[test]fn test_csv_parsing_basic() {diff --git a/crates/tabular_data_preview/src/renderer/preview_view.rs b/crates/tabular_data_preview/src/renderer/preview_view.rsindex e8c4822523f..505b18aea6b 100644--- a/crates/tabular_data_preview/src/renderer/preview_view.rs+++ b/crates/tabular_data_preview/src/renderer/preview_view.rs@@ -6,6 +6,14 @@ use crate::TabularDataPreviewPane;use super::settings::settings_popover_menu;+impl TabularDataPreviewPane {+ fn is_ready_to_render_content(&self) -> bool {+ !self.is_parsing+ && self.parse_error.is_none()+ && (self.engine.contents.number_of_cols > 0 || !self.engine.contents.rows.is_empty())+ }+}+impl Render for TabularDataPreviewPane {fn render(&mut self, window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {let theme = cx.theme();@@ -25,7 +33,7 @@ impl Render for TabularDataPreviewPane {.track_focus(&self.focus_handle).child({let is_parsing = self.is_parsing;- if is_parsing || self.engine.contents.number_of_cols == 0 {+ if !self.is_ready_to_render_content() {v_flex().size_full().child(@@ -54,7 +62,15 @@ impl Render for TabularDataPreviewPane {.child("Loading…"),)})- .when(!is_parsing, |div| div.child("No data to display")),+ .when(!is_parsing, |div| {+ if let Some(error) = &self.parse_error {+ div.p_4()+ .text_color(cx.theme().status().error)+ .child(error.clone())+ } else {+ div.child("No data to display")+ }+ }),).into_any_element()} else {diff --git a/crates/tabular_data_preview/src/renderer/render_table.rs b/crates/tabular_data_preview/src/renderer/render_table.rsindex 90e71a1d5ea..7ed0841f4bc 100644--- a/crates/tabular_data_preview/src/renderer/render_table.rs+++ b/crates/tabular_data_preview/src/renderer/render_table.rs@@ -17,7 +17,11 @@ impl TabularDataPreviewPane {current_widths: &Entity<ResizableColumnsState>,cx: &mut Context<Self>,) -> AnyElement {- self.create_table_inner(self.engine.contents.rows.len(), current_widths, cx)+ self.create_table_inner(+ self.engine.d2d_mapping().visible_row_count(),+ current_widths,+ cx,+ )}fn create_table_inner(@@ -164,6 +168,7 @@ impl TabularDataPreviewPane {format!("Pos {so}(L{slv})-{eo}(L{elv})")}TableCell::Virtual => "Virtual cell".into(),+ TableCell::Generated(_) => "Generated cell".into(),},))})diff --git a/crates/tabular_data_preview/src/table_data_engine.rs b/crates/tabular_data_preview/src/table_data_engine.rsindex 5a8f86a4659..b803439d6d4 100644--- a/crates/tabular_data_preview/src/table_data_engine.rs+++ b/crates/tabular_data_preview/src/table_data_engine.rs@@ -34,6 +34,30 @@ pub(crate) struct TableDataEngine {}impl TableDataEngine {+ pub(crate) fn set_contents(&mut self, contents: TableLikeContent) {+ if self+ .contents+ .headers+ .as_slice()+ .iter()+ .map(TableCell::display_value)+ .ne(contents+ .headers+ .as_slice()+ .iter()+ .map(TableCell::display_value))+ {+ // Filters and sorting use column indexes, which may now name different fields.+ self.filter_stack = FilterStack::default();+ self.applied_sorting = None;+ }+ self.contents = Arc::new(contents);+ // The previous mapping can reference rows removed by an edit. Keep it empty+ // until the background filter/sort task builds a mapping for the new contents.+ self.d2d_mapping = DisplayToDataMapping::default();+ self.calculate_available_filters();+ }+pub(crate) fn d2d_mapping(&self) -> &DisplayToDataMapping {&self.d2d_mapping}diff --git a/crates/tabular_data_preview/src/tabular_data_preview.rs b/crates/tabular_data_preview/src/tabular_data_preview.rsindex 8ec5689b85f..9b72d6f15aa 100644--- a/crates/tabular_data_preview/src/tabular_data_preview.rs+++ b/crates/tabular_data_preview/src/tabular_data_preview.rs@@ -33,6 +33,7 @@ pub struct TabularDataPreviewPane {pub(crate) column_widths: ColumnWidths,pub(crate) parsing_task: Option<Task<anyhow::Result<()>>>,pub(crate) is_parsing: bool,+ pub(crate) parse_error: Option<SharedString>,/// Background task computing the display-to-data mapping after a filter/sort change./// Stored here so that a new change cancels the previous in-flight computation.pub(crate) filter_sort_task: Option<Task<()>>,@@ -187,6 +188,7 @@ impl TabularDataPreviewPane {column_widths: ColumnWidths::new(cx, 1),parsing_task: None,is_parsing: false,+ parse_error: None,filter_sort_task: None,performance_metrics: PerformanceMetrics::default(),list_state: gpui::ListState::new(contents.rows.len(), ListAlignment::Top, px(1.))@@ -379,12 +381,12 @@ mod tests {let fs = FakeFs::new(cx.executor());fs.insert_tree(path!("/project"),- json!({ "inside.csv": "a,b\n1,2\n", "inside.txt": "plain" }),+ json!({ "inside.csv": "a,b\n1,2\n", "inside.jsonl": "{}\n", "inside.txt": "plain" }),).await;fs.insert_tree(path!("/elsewhere"),- json!({ "outside.csv": "a,b\n1,2\n", "outside.txt": "plain" }),+ json!({ "outside.csv": "a,b\n1,2\n", "outside.NDJSON": "{}\n", "outside.txt": "plain" }),).await;@@ -392,8 +394,10 @@ mod tests {for (abs_path, expected) in [(path!("/project/inside.csv"), true),+ (path!("/project/inside.jsonl"), true),(path!("/project/inside.txt"), false),(path!("/elsewhere/outside.csv"), true),+ (path!("/elsewhere/outside.NDJSON"), true),(path!("/elsewhere/outside.txt"), false),] {let buffer = project@@ -409,6 +413,211 @@ mod tests {}}+ #[gpui::test(iterations = 20)]+ async fn test_csv_preview_mapping_stays_valid_after_deleting_multiline_rows(+ cx: &mut TestAppContext,+ ) {+ use types::DisplayRow;++ init_test(cx);+ let result: anyhow::Result<()> = async {+ let fs = FakeFs::new(cx.executor());+ fs.insert_tree(+ path!("/project"),+ json!({ "records.csv": "id,note\n1,first\n2,\"two\nlines\"\n" }),+ )+ .await;+ let project = Project::test(fs, [Path::new(path!("/project"))], cx).await;+ let buffer = project+ .update(cx, |project, cx| {+ project.open_local_buffer(path!("/project/records.csv"), cx)+ })+ .await?;+ let (workspace, cx) =+ cx.add_window_view(|window, cx| Workspace::test_new(project.clone(), window, cx));+ let editor = cx.update(|window, cx| {+ cx.new(|cx| Editor::for_buffer(buffer, Some(project), window, cx))+ });+ let preview = workspace.update_in(cx, |workspace, window, cx| {+ let pane = workspace.active_pane().clone();+ TabularDataPreviewPane::open_preview_in_pane(+ editor.clone(),+ pane.clone(),+ window,+ cx,+ );+ pane.read(cx)+ .items_of_type::<TabularDataPreviewPane>()+ .next()+ });+ let Some(preview) = preview else {+ anyhow::bail!("preview did not open");+ };+ cx.condition(&preview, |preview, _| {+ !preview.is_parsing && preview.engine.d2d_mapping().visible_row_count() == 2+ })+ .await;++ let _subscription = cx.update(|_, cx| {+ cx.observe(&preview, |preview, cx| {+ let preview = preview.read(cx);+ if !preview.is_parsing && preview.parse_error.is_none() {+ let mapping = preview.engine.d2d_mapping();+ assert_eq!(preview.list_state.item_count(), mapping.visible_row_count());+ for display_row in 0..mapping.visible_row_count() {+ assert!(+ mapping+ .get_data_row(DisplayRow(display_row))+ .and_then(|data_row| preview.engine.contents.get_row(data_row))+ .is_some(),+ "display mapping points to a deleted row"+ );+ }+ }+ })+ });++ for (text, expected_rows) in [+ (+ "id,note\n1,first\n2,\"two\nlines\"\n3,\"pasted\ntext\"\n",+ 3,+ ),+ ("id,note\n1,first\n", 1),+ ("id,note\n", 0),+ ("id,note\n1,\"restored\ntext\"\n", 1),+ ] {+ editor.update_in(cx, |editor, window, cx| {+ editor.set_text(text, window, cx);+ });+ cx.condition(&preview, |preview, _| {+ !preview.is_parsing+ && preview.engine.contents.rows.len() == expected_rows+ && preview.engine.d2d_mapping().visible_row_count() == expected_rows+ })+ .await;+ }+ Ok(())+ }+ .await;+ assert!(result.is_ok(), "{result:?}");+ }++ #[gpui::test]+ async fn test_json_lines_preview_recovers_after_edits(cx: &mut TestAppContext) {+ use table_data_engine::sorting_by_column::{AppliedSorting, SortDirection};+ use types::{AnyColumn, DataRow, DisplayRow};++ init_test(cx);+ let result: anyhow::Result<()> = async {+ let fs = FakeFs::new(cx.executor());+ fs.insert_tree(+ path!("/project"),+ json!({ "records.jsonl": "{\"name\":\"Grace\"}\n{\"name\":\"Ada\"}\n" }),+ )+ .await;+ let project = Project::test(fs, [Path::new(path!("/project"))], cx).await;+ let buffer = project+ .update(cx, |project, cx| {+ project.open_local_buffer(path!("/project/records.jsonl"), cx)+ })+ .await?;+ let (workspace, cx) =+ cx.add_window_view(|window, cx| Workspace::test_new(project.clone(), window, cx));+ let editor = cx.update(|window, cx| {+ cx.new(|cx| Editor::for_buffer(buffer, Some(project), window, cx))+ });+ let preview = workspace.update_in(cx, |workspace, window, cx| {+ let pane = workspace.active_pane().clone();+ TabularDataPreviewPane::open_preview_in_pane(+ editor.clone(),+ pane.clone(),+ window,+ cx,+ );+ pane.read(cx)+ .items_of_type::<TabularDataPreviewPane>()+ .next()+ });+ let Some(preview) = preview else {+ anyhow::bail!("preview did not open");+ };+ cx.condition(&preview, |preview, _| {+ !preview.is_parsing && preview.engine.d2d_mapping().visible_row_count() == 2+ })+ .await;++ preview.update(cx, |preview, cx| {+ preview.engine.applied_sorting = Some(AppliedSorting {+ col_idx: AnyColumn(0),+ direction: SortDirection::Asc,+ });+ preview.toggle_filter(AnyColumn(0), Some(r#""Ada""#.into()), cx);+ });+ cx.condition(&preview, |preview, _| {+ preview.engine.d2d_mapping().visible_row_count() == 1+ })+ .await;+ preview.read_with(cx, |preview, _| {+ assert_eq!(+ preview.engine.d2d_mapping().get_data_row(DisplayRow(0)),+ Some(DataRow(1))+ );+ });++ editor.update_in(cx, |editor, window, cx| {+ editor.set_text("{\"name\":\"Ada\"}\n{", window, cx);+ });+ cx.condition(&preview, |preview, _| {+ !preview.is_parsing && preview.parse_error.is_some()+ })+ .await;+ preview.read_with(cx, |preview, _| {+ assert!(+ preview+ .parse_error+ .as_ref()+ .is_some_and(|error| error.contains("line 2"))+ );+ });++ editor.update_in(cx, |editor, window, cx| {+ editor.set_text("{\"name\":\"Ada\"}\n{\"name\":\"Grace\"}", window, cx);+ });+ cx.condition(&preview, |preview, _| {+ !preview.is_parsing+ && preview.parse_error.is_none()+ && preview.engine.d2d_mapping().get_data_row(DisplayRow(0)) == Some(DataRow(0))+ })+ .await;+ preview.read_with(cx, |preview, _| {+ assert!(preview.engine.has_active_filters(AnyColumn(0)));+ assert!(preview.engine.applied_sorting.is_some());+ });++ editor.update_in(cx, |editor, window, cx| {+ editor.set_text(+ "{\"age\":36,\"name\":\"Ada\"}\n{\"name\":\"Grace\"}",+ window,+ cx,+ );+ });+ cx.condition(&preview, |preview, _| {+ !preview.is_parsing+ && preview.engine.contents.number_of_cols == 2+ && preview.engine.d2d_mapping().visible_row_count() == 2+ })+ .await;+ preview.read_with(cx, |preview, _| {+ assert!(!preview.engine.has_active_filters(AnyColumn(0)));+ assert!(preview.engine.applied_sorting.is_none());+ assert!(preview.parse_error.is_none());+ });+ Ok(())+ }+ .await;+ assert!(result.is_ok(), "{result:?}");+ }+fn init_test(cx: &mut TestAppContext) {cx.update(|cx| {AppState::test(cx);diff --git a/crates/tabular_data_preview/src/types/table_cell.rs b/crates/tabular_data_preview/src/types/table_cell.rsindex 4e9c8bb0b66..64ba8cb51bc 100644--- a/crates/tabular_data_preview/src/types/table_cell.rs+++ b/crates/tabular_data_preview/src/types/table_cell.rs@@ -20,6 +20,8 @@ pub enum TableCell {/// Cached display value (for performance)cached_value: SharedString,},+ /// Display text without a source span, used for generated column headings.+ Generated(SharedString),/// Virtual cell, created to pad malformed rowVirtual,}@@ -48,6 +50,7 @@ impl TableCell {pub fn display_value(&self) -> Option<&SharedString> {match self {TableCell::Real { cached_value, .. } => Some(cached_value),+ TableCell::Generated(value) => Some(value),TableCell::Virtual => None,}}diff --git a/docs/src/languages/json.md b/docs/src/languages/json.mdindex dcede992407..6aadc0c8565 100644--- a/docs/src/languages/json.md+++ b/docs/src/languages/json.md@@ -10,6 +10,14 @@ JSON support is available natively in Zed.- Tree-sitter: [tree-sitter/tree-sitter-json](https://github.com/tree-sitter/tree-sitter-json)- Language Server: [zed-industries/json-language-server](https://github.com/zed-industries/json-language-server)+## JSON Lines Preview++Open a `.jsonl` or `.ndjson` file and run {#action tabular_data::OpenPreview} to view it as a read-only table. Use {#action tabular_data::OpenPreviewToTheSide} to keep the source visible alongside the preview.++Each nonblank line must contain a JSON object. Top-level keys become columns in the order they first appear in the file. Keys from the first record keep their source order, and new keys from later records are appended to the right. Missing fields appear as empty cells. Values retain their JSON representation, so `null`, `"null"`, and `""` remain distinct; nested objects and arrays appear as compact JSON.++The preview updates as you edit the source. Invalid records show an error with the source line number. Sorting compares the displayed text, and changing the column names or order clears active sorting and filters.+## JSONCZed also supports a super-set of JSON called JSONC, which allows single line comments (`//`) in JSON files.