6fca1d2b0b
There's still a bit more work to do on this, but this PR is compiling (with warnings) after eliminating the key types. When the tasks below are complete, this will be the new narrative for GPUI: - `Entity<T>` - This replaces `View<T>`/`Model<T>`. It represents a unit of state, and if `T` implements `Render`, then `Entity<T>` implements `Element`. - `&mut App` This replaces `AppContext` and represents the app. - `&mut Context<T>` This replaces `ModelContext` and derefs to `App`. It is provided by the framework when updating an entity. - `&mut Window` Broken out of `&mut WindowContext` which no longer exists. Every method that once took `&mut WindowContext` now takes `&mut Window, &mut App` and every method that took `&mut ViewContext<T>` now takes `&mut Window, &mut Context<T>` Not pictured here are the two other failed attempts. It's been quite a month! Tasks: - [x] Remove `View`, `ViewContext`, `WindowContext` and thread through `Window` - [x] [@cole-miller @mikayla-maki] Redraw window when entities change - [x] [@cole-miller @mikayla-maki] Get examples and Zed running - [x] [@cole-miller @mikayla-maki] Fix Zed rendering - [x] [@mikayla-maki] Fix todo! macros and comments - [x] Fix a bug where the editor would not be redrawn because of view caching - [x] remove publicness window.notify() and replace with `AppContext::notify` - [x] remove `observe_new_window_models`, replace with `observe_new_models` with an optional window - [x] Fix a bug where the project panel would not be redrawn because of the wrong refresh() call being used - [x] Fix the tests - [x] Fix warnings by eliminating `Window` params or using `_` - [x] Fix conflicts - [x] Simplify generic code where possible - [x] Rename types - [ ] Update docs ### issues post merge - [x] Issues switching between normal and insert mode - [x] Assistant re-rendering failure - [x] Vim test failures - [x] Mac build issue Release Notes: - N/A --------- Co-authored-by: Antonio Scandurra <me@as-cii.com> Co-authored-by: Cole Miller <cole@zed.dev> Co-authored-by: Mikayla <mikayla@zed.dev> Co-authored-by: Joseph <joseph@zed.dev> Co-authored-by: max <max@zed.dev> Co-authored-by: Michael Sloan <michael@zed.dev> Co-authored-by: Mikayla Maki <mikaylamaki@Mikaylas-MacBook-Pro.local> Co-authored-by: Mikayla <mikayla.c.maki@gmail.com> Co-authored-by: joão <joao@zed.dev>
547 lines
19 KiB
Rust
547 lines
19 KiB
Rust
//! # REPL Output Module
|
|
//!
|
|
//! This module provides the core functionality for handling and displaying
|
|
//! various types of output from Jupyter kernels.
|
|
//!
|
|
//! ## Key Components
|
|
//!
|
|
//! - `OutputContent`: An enum that encapsulates different types of output content.
|
|
//! - `ExecutionView`: Manages the display of outputs for a single execution.
|
|
//! - `ExecutionStatus`: Represents the current status of an execution.
|
|
//!
|
|
//! ## Output Types
|
|
//!
|
|
//! The module supports several output types, including:
|
|
//! - Plain text
|
|
//! - Markdown
|
|
//! - Images (PNG and JPEG)
|
|
//! - Tables
|
|
//! - Error messages
|
|
//!
|
|
//! ## Clipboard Support
|
|
//!
|
|
//! Most output types implement the `SupportsClipboard` trait, allowing
|
|
//! users to easily copy output content to the system clipboard.
|
|
//!
|
|
//! ## Rendering
|
|
//!
|
|
//! The module provides rendering capabilities for each output type,
|
|
//! ensuring proper display within the REPL interface.
|
|
//!
|
|
//! ## Jupyter Integration
|
|
//!
|
|
//! This module is designed to work with Jupyter message protocols,
|
|
//! interpreting and displaying various types of Jupyter output.
|
|
|
|
use std::time::Duration;
|
|
|
|
use editor::{Editor, MultiBuffer};
|
|
use gpui::{
|
|
percentage, Animation, AnimationExt, AnyElement, ClipboardItem, Entity, Render, Transformation,
|
|
WeakEntity,
|
|
};
|
|
use language::Buffer;
|
|
use runtimelib::{ExecutionState, JupyterMessageContent, MimeBundle, MimeType};
|
|
use ui::{div, prelude::*, v_flex, Context, IntoElement, Styled, Tooltip, Window};
|
|
|
|
mod image;
|
|
use image::ImageView;
|
|
|
|
mod markdown;
|
|
use markdown::MarkdownView;
|
|
|
|
mod table;
|
|
use table::TableView;
|
|
|
|
pub mod plain;
|
|
use plain::TerminalOutput;
|
|
|
|
pub(crate) mod user_error;
|
|
use user_error::ErrorView;
|
|
use workspace::Workspace;
|
|
|
|
/// When deciding what to render from a collection of mediatypes, we need to rank them in order of importance
|
|
fn rank_mime_type(mimetype: &MimeType) -> usize {
|
|
match mimetype {
|
|
MimeType::DataTable(_) => 6,
|
|
MimeType::Png(_) => 4,
|
|
MimeType::Jpeg(_) => 3,
|
|
MimeType::Markdown(_) => 2,
|
|
MimeType::Plain(_) => 1,
|
|
// All other media types are not supported in Zed at this time
|
|
_ => 0,
|
|
}
|
|
}
|
|
|
|
pub(crate) trait OutputContent {
|
|
fn clipboard_content(&self, window: &Window, cx: &App) -> Option<ClipboardItem>;
|
|
fn has_clipboard_content(&self, _window: &Window, _cx: &App) -> bool {
|
|
false
|
|
}
|
|
fn has_buffer_content(&self, _window: &Window, _cx: &App) -> bool {
|
|
false
|
|
}
|
|
fn buffer_content(&mut self, _window: &mut Window, _cx: &mut App) -> Option<Entity<Buffer>> {
|
|
None
|
|
}
|
|
}
|
|
|
|
impl<V: OutputContent + 'static> OutputContent for Entity<V> {
|
|
fn clipboard_content(&self, window: &Window, cx: &App) -> Option<ClipboardItem> {
|
|
self.read(cx).clipboard_content(window, cx)
|
|
}
|
|
|
|
fn has_clipboard_content(&self, window: &Window, cx: &App) -> bool {
|
|
self.read(cx).has_clipboard_content(window, cx)
|
|
}
|
|
|
|
fn has_buffer_content(&self, window: &Window, cx: &App) -> bool {
|
|
self.read(cx).has_buffer_content(window, cx)
|
|
}
|
|
|
|
fn buffer_content(&mut self, window: &mut Window, cx: &mut App) -> Option<Entity<Buffer>> {
|
|
self.update(cx, |item, cx| item.buffer_content(window, cx))
|
|
}
|
|
}
|
|
|
|
pub enum Output {
|
|
Plain {
|
|
content: Entity<TerminalOutput>,
|
|
display_id: Option<String>,
|
|
},
|
|
Stream {
|
|
content: Entity<TerminalOutput>,
|
|
},
|
|
Image {
|
|
content: Entity<ImageView>,
|
|
display_id: Option<String>,
|
|
},
|
|
ErrorOutput(ErrorView),
|
|
Message(String),
|
|
Table {
|
|
content: Entity<TableView>,
|
|
display_id: Option<String>,
|
|
},
|
|
Markdown {
|
|
content: Entity<MarkdownView>,
|
|
display_id: Option<String>,
|
|
},
|
|
ClearOutputWaitMarker,
|
|
}
|
|
|
|
impl Output {
|
|
fn render_output_controls<V: OutputContent + 'static>(
|
|
v: Entity<V>,
|
|
workspace: WeakEntity<Workspace>,
|
|
window: &mut Window,
|
|
cx: &mut Context<ExecutionView>,
|
|
) -> Option<AnyElement> {
|
|
if !v.has_clipboard_content(window, cx) && !v.has_buffer_content(window, cx) {
|
|
return None;
|
|
}
|
|
|
|
Some(
|
|
h_flex()
|
|
.pl_1()
|
|
.when(v.has_clipboard_content(window, cx), |el| {
|
|
let v = v.clone();
|
|
el.child(
|
|
IconButton::new(ElementId::Name("copy-output".into()), IconName::Copy)
|
|
.style(ButtonStyle::Transparent)
|
|
.tooltip(Tooltip::text("Copy Output"))
|
|
.on_click(cx.listener(move |_, _, window, cx| {
|
|
let clipboard_content = v.clipboard_content(window, cx);
|
|
|
|
if let Some(clipboard_content) = clipboard_content.as_ref() {
|
|
cx.write_to_clipboard(clipboard_content.clone());
|
|
}
|
|
})),
|
|
)
|
|
})
|
|
.when(v.has_buffer_content(window, cx), |el| {
|
|
let v = v.clone();
|
|
el.child(
|
|
IconButton::new(
|
|
ElementId::Name("open-in-buffer".into()),
|
|
IconName::FileText,
|
|
)
|
|
.style(ButtonStyle::Transparent)
|
|
.tooltip(Tooltip::text("Open in Buffer"))
|
|
.on_click(cx.listener({
|
|
let workspace = workspace.clone();
|
|
|
|
move |_, _, window, cx| {
|
|
let buffer_content =
|
|
v.update(cx, |item, cx| item.buffer_content(window, cx));
|
|
|
|
if let Some(buffer_content) = buffer_content.as_ref() {
|
|
let buffer = buffer_content.clone();
|
|
let editor = Box::new(cx.new(|cx| {
|
|
let multibuffer = cx.new(|cx| {
|
|
let mut multi_buffer =
|
|
MultiBuffer::singleton(buffer.clone(), cx);
|
|
|
|
multi_buffer.set_title("REPL Output".to_string(), cx);
|
|
multi_buffer
|
|
});
|
|
|
|
Editor::for_multibuffer(
|
|
multibuffer,
|
|
None,
|
|
false,
|
|
window,
|
|
cx,
|
|
)
|
|
}));
|
|
workspace
|
|
.update(cx, |workspace, cx| {
|
|
workspace.add_item_to_active_pane(
|
|
editor, None, true, window, cx,
|
|
);
|
|
})
|
|
.ok();
|
|
}
|
|
}
|
|
})),
|
|
)
|
|
})
|
|
.into_any_element(),
|
|
)
|
|
}
|
|
|
|
pub fn render(
|
|
&self,
|
|
|
|
workspace: WeakEntity<Workspace>,
|
|
window: &mut Window,
|
|
cx: &mut Context<ExecutionView>,
|
|
) -> impl IntoElement {
|
|
let content = match self {
|
|
Self::Plain { content, .. } => Some(content.clone().into_any_element()),
|
|
Self::Markdown { content, .. } => Some(content.clone().into_any_element()),
|
|
Self::Stream { content, .. } => Some(content.clone().into_any_element()),
|
|
Self::Image { content, .. } => Some(content.clone().into_any_element()),
|
|
Self::Message(message) => Some(div().child(message.clone()).into_any_element()),
|
|
Self::Table { content, .. } => Some(content.clone().into_any_element()),
|
|
Self::ErrorOutput(error_view) => error_view.render(window, cx),
|
|
Self::ClearOutputWaitMarker => None,
|
|
};
|
|
|
|
h_flex()
|
|
.w_full()
|
|
.items_start()
|
|
.child(div().flex_1().children(content))
|
|
.children(match self {
|
|
Self::Plain { content, .. } => {
|
|
Self::render_output_controls(content.clone(), workspace.clone(), window, cx)
|
|
}
|
|
Self::Markdown { content, .. } => {
|
|
Self::render_output_controls(content.clone(), workspace.clone(), window, cx)
|
|
}
|
|
Self::Stream { content, .. } => {
|
|
Self::render_output_controls(content.clone(), workspace.clone(), window, cx)
|
|
}
|
|
Self::Image { content, .. } => {
|
|
Self::render_output_controls(content.clone(), workspace.clone(), window, cx)
|
|
}
|
|
Self::ErrorOutput(err) => Self::render_output_controls(
|
|
err.traceback.clone(),
|
|
workspace.clone(),
|
|
window,
|
|
cx,
|
|
),
|
|
Self::Message(_) => None,
|
|
Self::Table { content, .. } => {
|
|
Self::render_output_controls(content.clone(), workspace.clone(), window, cx)
|
|
}
|
|
Self::ClearOutputWaitMarker => None,
|
|
})
|
|
}
|
|
|
|
pub fn display_id(&self) -> Option<String> {
|
|
match self {
|
|
Output::Plain { display_id, .. } => display_id.clone(),
|
|
Output::Stream { .. } => None,
|
|
Output::Image { display_id, .. } => display_id.clone(),
|
|
Output::ErrorOutput(_) => None,
|
|
Output::Message(_) => None,
|
|
Output::Table { display_id, .. } => display_id.clone(),
|
|
Output::Markdown { display_id, .. } => display_id.clone(),
|
|
Output::ClearOutputWaitMarker => None,
|
|
}
|
|
}
|
|
|
|
pub fn new(
|
|
data: &MimeBundle,
|
|
display_id: Option<String>,
|
|
window: &mut Window,
|
|
cx: &mut App,
|
|
) -> Self {
|
|
match data.richest(rank_mime_type) {
|
|
Some(MimeType::Plain(text)) => Output::Plain {
|
|
content: cx.new(|cx| TerminalOutput::from(text, window, cx)),
|
|
display_id,
|
|
},
|
|
Some(MimeType::Markdown(text)) => {
|
|
let content = cx.new(|cx| MarkdownView::from(text.clone(), cx));
|
|
Output::Markdown {
|
|
content,
|
|
display_id,
|
|
}
|
|
}
|
|
Some(MimeType::Png(data)) | Some(MimeType::Jpeg(data)) => match ImageView::from(data) {
|
|
Ok(view) => Output::Image {
|
|
content: cx.new(|_| view),
|
|
display_id,
|
|
},
|
|
Err(error) => Output::Message(format!("Failed to load image: {}", error)),
|
|
},
|
|
Some(MimeType::DataTable(data)) => Output::Table {
|
|
content: cx.new(|cx| TableView::new(data, window, cx)),
|
|
display_id,
|
|
},
|
|
// Any other media types are not supported
|
|
_ => Output::Message("Unsupported media type".to_string()),
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Default, Clone, Debug)]
|
|
pub enum ExecutionStatus {
|
|
#[default]
|
|
Unknown,
|
|
ConnectingToKernel,
|
|
Queued,
|
|
Executing,
|
|
Finished,
|
|
ShuttingDown,
|
|
Shutdown,
|
|
KernelErrored(String),
|
|
Restarting,
|
|
}
|
|
|
|
/// An ExecutionView shows the outputs of an execution.
|
|
/// It can hold zero or more outputs, which the user
|
|
/// sees as "the output" for a single execution.
|
|
pub struct ExecutionView {
|
|
#[allow(unused)]
|
|
workspace: WeakEntity<Workspace>,
|
|
pub outputs: Vec<Output>,
|
|
pub status: ExecutionStatus,
|
|
}
|
|
|
|
impl ExecutionView {
|
|
pub fn new(
|
|
status: ExecutionStatus,
|
|
workspace: WeakEntity<Workspace>,
|
|
_cx: &mut Context<Self>,
|
|
) -> Self {
|
|
Self {
|
|
workspace,
|
|
outputs: Default::default(),
|
|
status,
|
|
}
|
|
}
|
|
|
|
/// Accept a Jupyter message belonging to this execution
|
|
pub fn push_message(
|
|
&mut self,
|
|
message: &JupyterMessageContent,
|
|
window: &mut Window,
|
|
cx: &mut Context<Self>,
|
|
) {
|
|
let output: Output = match message {
|
|
JupyterMessageContent::ExecuteResult(result) => Output::new(
|
|
&result.data,
|
|
result.transient.as_ref().and_then(|t| t.display_id.clone()),
|
|
window,
|
|
cx,
|
|
),
|
|
JupyterMessageContent::DisplayData(result) => Output::new(
|
|
&result.data,
|
|
result.transient.as_ref().and_then(|t| t.display_id.clone()),
|
|
window,
|
|
cx,
|
|
),
|
|
JupyterMessageContent::StreamContent(result) => {
|
|
// Previous stream data will combine together, handling colors, carriage returns, etc
|
|
if let Some(new_terminal) = self.apply_terminal_text(&result.text, window, cx) {
|
|
new_terminal
|
|
} else {
|
|
return;
|
|
}
|
|
}
|
|
JupyterMessageContent::ErrorOutput(result) => {
|
|
let terminal =
|
|
cx.new(|cx| TerminalOutput::from(&result.traceback.join("\n"), window, cx));
|
|
|
|
Output::ErrorOutput(ErrorView {
|
|
ename: result.ename.clone(),
|
|
evalue: result.evalue.clone(),
|
|
traceback: terminal,
|
|
})
|
|
}
|
|
JupyterMessageContent::ExecuteReply(reply) => {
|
|
for payload in reply.payload.iter() {
|
|
if let runtimelib::Payload::Page { data, .. } = payload {
|
|
let output = Output::new(data, None, window, cx);
|
|
self.outputs.push(output);
|
|
}
|
|
}
|
|
cx.notify();
|
|
return;
|
|
}
|
|
JupyterMessageContent::ClearOutput(options) => {
|
|
if !options.wait {
|
|
self.outputs.clear();
|
|
cx.notify();
|
|
return;
|
|
}
|
|
|
|
// Create a marker to clear the output after we get in a new output
|
|
Output::ClearOutputWaitMarker
|
|
}
|
|
JupyterMessageContent::Status(status) => {
|
|
match status.execution_state {
|
|
ExecutionState::Busy => {
|
|
self.status = ExecutionStatus::Executing;
|
|
}
|
|
ExecutionState::Idle => self.status = ExecutionStatus::Finished,
|
|
}
|
|
cx.notify();
|
|
return;
|
|
}
|
|
_msg => {
|
|
return;
|
|
}
|
|
};
|
|
|
|
// Check for a clear output marker as the previous output, so we can clear it out
|
|
if let Some(output) = self.outputs.last() {
|
|
if let Output::ClearOutputWaitMarker = output {
|
|
self.outputs.clear();
|
|
}
|
|
}
|
|
|
|
self.outputs.push(output);
|
|
|
|
cx.notify();
|
|
}
|
|
|
|
pub fn update_display_data(
|
|
&mut self,
|
|
data: &MimeBundle,
|
|
display_id: &str,
|
|
window: &mut Window,
|
|
cx: &mut Context<Self>,
|
|
) {
|
|
let mut any = false;
|
|
|
|
self.outputs.iter_mut().for_each(|output| {
|
|
if let Some(other_display_id) = output.display_id().as_ref() {
|
|
if other_display_id == display_id {
|
|
*output = Output::new(data, Some(display_id.to_owned()), window, cx);
|
|
any = true;
|
|
}
|
|
}
|
|
});
|
|
|
|
if any {
|
|
cx.notify();
|
|
}
|
|
}
|
|
|
|
fn apply_terminal_text(
|
|
&mut self,
|
|
text: &str,
|
|
window: &mut Window,
|
|
cx: &mut Context<Self>,
|
|
) -> Option<Output> {
|
|
if let Some(last_output) = self.outputs.last_mut() {
|
|
if let Output::Stream {
|
|
content: last_stream,
|
|
} = last_output
|
|
{
|
|
// Don't need to add a new output, we already have a terminal output
|
|
// and can just update the most recent terminal output
|
|
last_stream.update(cx, |last_stream, cx| {
|
|
last_stream.append_text(text, cx);
|
|
cx.notify();
|
|
});
|
|
return None;
|
|
}
|
|
}
|
|
|
|
Some(Output::Stream {
|
|
content: cx.new(|cx| TerminalOutput::from(text, window, cx)),
|
|
})
|
|
}
|
|
}
|
|
|
|
impl Render for ExecutionView {
|
|
fn render(&mut self, window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
|
|
let status = match &self.status {
|
|
ExecutionStatus::ConnectingToKernel => Label::new("Connecting to kernel...")
|
|
.color(Color::Muted)
|
|
.into_any_element(),
|
|
ExecutionStatus::Executing => h_flex()
|
|
.gap_2()
|
|
.child(
|
|
Icon::new(IconName::ArrowCircle)
|
|
.size(IconSize::Small)
|
|
.color(Color::Muted)
|
|
.with_animation(
|
|
"arrow-circle",
|
|
Animation::new(Duration::from_secs(3)).repeat(),
|
|
|icon, delta| icon.transform(Transformation::rotate(percentage(delta))),
|
|
),
|
|
)
|
|
.child(Label::new("Executing...").color(Color::Muted))
|
|
.into_any_element(),
|
|
ExecutionStatus::Finished => Icon::new(IconName::Check)
|
|
.size(IconSize::Small)
|
|
.into_any_element(),
|
|
ExecutionStatus::Unknown => Label::new("Unknown status")
|
|
.color(Color::Muted)
|
|
.into_any_element(),
|
|
ExecutionStatus::ShuttingDown => Label::new("Kernel shutting down...")
|
|
.color(Color::Muted)
|
|
.into_any_element(),
|
|
ExecutionStatus::Restarting => Label::new("Kernel restarting...")
|
|
.color(Color::Muted)
|
|
.into_any_element(),
|
|
ExecutionStatus::Shutdown => Label::new("Kernel shutdown")
|
|
.color(Color::Muted)
|
|
.into_any_element(),
|
|
ExecutionStatus::Queued => Label::new("Queued...")
|
|
.color(Color::Muted)
|
|
.into_any_element(),
|
|
ExecutionStatus::KernelErrored(error) => Label::new(format!("Kernel error: {}", error))
|
|
.color(Color::Error)
|
|
.into_any_element(),
|
|
};
|
|
|
|
if self.outputs.is_empty() {
|
|
return v_flex()
|
|
.min_h(window.line_height())
|
|
.justify_center()
|
|
.child(status)
|
|
.into_any_element();
|
|
}
|
|
|
|
div()
|
|
.w_full()
|
|
.children(
|
|
self.outputs
|
|
.iter()
|
|
.map(|output| output.render(self.workspace.clone(), window, cx)),
|
|
)
|
|
.children(match self.status {
|
|
ExecutionStatus::Executing => vec![status],
|
|
ExecutionStatus::Queued => vec![status],
|
|
_ => vec![],
|
|
})
|
|
.into_any_element()
|
|
}
|
|
}
|