484 lines · 16.6 KB · Rust
RawDownload
use std::sync::Arc; use crate::stdio::TerminalOutput;use anyhow::Result;use gpui::{img, AnyElement, FontWeight, ImageData, Render, View};use runtimelib::datatable::TableSchema;use runtimelib::media::datatable::TabularDataResource;use runtimelib::{ExecutionState, JupyterMessageContent, MimeBundle, MimeType};use serde_json::Value;use ui::{div, prelude::*, v_flex, IntoElement, Styled, ViewContext}; // Given these outputs are destined for the editor with the block decorations API, all of them must report// how many lines they will take up in the editor.pub trait LineHeight: Sized {    fn num_lines(&self, cx: &mut WindowContext) -> u8;} // When deciding what to render from a collection of mediatypes, we need to rank them in order of importancefn 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,    }} /// ImageView renders an image inline in an editor, adapting to the line height to fit the image.pub struct ImageView {    height: u32,    width: u32,    image: Arc<ImageData>,} impl ImageView {    fn render(&self, cx: &ViewContext<ExecutionView>) -> AnyElement {        let line_height = cx.line_height();         let (height, width) = if self.height as f32 / line_height.0 == u8::MAX as f32 {            let height = u8::MAX as f32 * line_height.0;            let width = self.width as f32 * height / self.height as f32;            (height, width)        } else {            (self.height as f32, self.width as f32)        };         let image = self.image.clone();         div()            .h(Pixels(height))            .w(Pixels(width))            .child(img(image))            .into_any_element()    }     fn from(base64_encoded_data: &str) -> Result<Self> {        let bytes = base64::decode(base64_encoded_data)?;         let format = image::guess_format(&bytes)?;        let mut data = image::load_from_memory_with_format(&bytes, format)?.into_rgba8();         // Convert from RGBA to BGRA.        for pixel in data.chunks_exact_mut(4) {            pixel.swap(0, 2);        }         let height = data.height();        let width = data.width();         let gpui_image_data = ImageData::new(data);         return Ok(ImageView {            height,            width,            image: Arc::new(gpui_image_data),        });    }} impl LineHeight for ImageView {    fn num_lines(&self, cx: &mut WindowContext) -> u8 {        let line_height = cx.line_height();         let lines = self.height as f32 / line_height.0;         if lines > u8::MAX as f32 {            return u8::MAX;        }        lines as u8    }} /// TableView renders a static table inline in a buffer./// It uses the https://specs.frictionlessdata.io/tabular-data-resource/ specification for data interchange.pub struct TableView {    pub table: TabularDataResource,} impl TableView {    pub fn render(&self, cx: &ViewContext<ExecutionView>) -> AnyElement {        let data = match &self.table.data {            Some(data) => data,            None => return div().into_any_element(),        };         // todo!(): compute the width of each column by finding the widest cell in each column         let mut headings = serde_json::Map::new();        for field in &self.table.schema.fields {            headings.insert(field.name.clone(), Value::String(field.name.clone()));        }        let header = self.render_row(&self.table.schema, true, &Value::Object(headings), cx);         let body = data            .iter()            .map(|row| self.render_row(&self.table.schema, false, &row, cx));         v_flex()            .w_full()            .child(header)            .children(body)            .into_any_element()    }     pub fn render_row(        &self,        schema: &TableSchema,        is_header: bool,        row: &Value,        cx: &ViewContext<ExecutionView>,    ) -> AnyElement {        let theme = cx.theme();         let row_cells = schema            .fields            .iter()            .map(|field| {                let container = match field.field_type {                    runtimelib::datatable::FieldType::String => div(),                     runtimelib::datatable::FieldType::Number                    | runtimelib::datatable::FieldType::Integer                    | runtimelib::datatable::FieldType::Date                    | runtimelib::datatable::FieldType::Time                    | runtimelib::datatable::FieldType::Datetime                    | runtimelib::datatable::FieldType::Year                    | runtimelib::datatable::FieldType::Duration                    | runtimelib::datatable::FieldType::Yearmonth => v_flex().items_end(),                     _ => div(),                };                 let value = match row.get(&field.name) {                    Some(Value::String(s)) => s.clone(),                    Some(Value::Number(n)) => n.to_string(),                    Some(Value::Bool(b)) => b.to_string(),                    Some(Value::Array(arr)) => format!("{:?}", arr),                    Some(Value::Object(obj)) => format!("{:?}", obj),                    Some(Value::Null) | None => String::new(),                };                 let mut cell = container                    .w_full()                    .child(value)                    .px_2()                    .py_1()                    .border_color(theme.colors().border);                 if is_header {                    cell = cell.border_2().bg(theme.colors().border_focused)                } else {                    cell = cell.border_1()                }                cell            })            .collect::<Vec<_>>();         h_flex().children(row_cells).into_any_element()    }} impl LineHeight for TableView {    fn num_lines(&self, _cx: &mut WindowContext) -> u8 {        let num_rows = match &self.table.data {            Some(data) => data.len(),            // We don't support Path based data sources            None => 0,        };         // Given that each cell has both `py_1` and a border, we have to estimate        // a reasonable size to add on, then round up.        let row_heights = (num_rows as f32 * 1.2) + 1.0;         (row_heights as u8).saturating_add(2) // Header + spacing    }} // Userspace error from the kernelpub struct ErrorView {    pub ename: String,    pub evalue: String,    pub traceback: TerminalOutput,} impl ErrorView {    fn render(&self, cx: &ViewContext<ExecutionView>) -> Option<AnyElement> {        let theme = cx.theme();         let colors = cx.theme().colors();         Some(            v_flex()                .w_full()                .bg(colors.background)                .p_4()                .border_l_1()                .border_color(theme.status().error_border)                .child(                    h_flex()                        .font_weight(FontWeight::BOLD)                        .child(format!("{}: {}", self.ename, self.evalue)),                )                .child(self.traceback.render(cx))                .into_any_element(),        )    }} impl LineHeight for ErrorView {    fn num_lines(&self, cx: &mut WindowContext) -> u8 {        let mut height: u8 = 0;        height = height.saturating_add(self.ename.lines().count() as u8);        height = height.saturating_add(self.evalue.lines().count() as u8);        height = height.saturating_add(self.traceback.num_lines(cx));        height    }} pub enum OutputType {    Plain(TerminalOutput),    Stream(TerminalOutput),    Image(ImageView),    ErrorOutput(ErrorView),    Message(String),    Table(TableView),    ClearOutputWaitMarker,} impl OutputType {    fn render(&self, cx: &ViewContext<ExecutionView>) -> Option<AnyElement> {        let el = match self {            // Note: in typical frontends we would show the execute_result.execution_count            // Here we can just handle either            Self::Plain(stdio) => Some(stdio.render(cx)),            // Self::Markdown(markdown) => Some(markdown.render(theme)),            Self::Stream(stdio) => Some(stdio.render(cx)),            Self::Image(image) => Some(image.render(cx)),            Self::Message(message) => Some(div().child(message.clone()).into_any_element()),            Self::Table(table) => Some(table.render(cx)),            Self::ErrorOutput(error_view) => error_view.render(cx),            Self::ClearOutputWaitMarker => None,        };         el    }} impl LineHeight for OutputType {    /// Calculates the expected number of lines    fn num_lines(&self, cx: &mut WindowContext) -> u8 {        match self {            Self::Plain(stdio) => stdio.num_lines(cx),            Self::Stream(stdio) => stdio.num_lines(cx),            Self::Image(image) => image.num_lines(cx),            Self::Message(message) => message.lines().count() as u8,            Self::Table(table) => table.num_lines(cx),            Self::ErrorOutput(error_view) => error_view.num_lines(cx),            Self::ClearOutputWaitMarker => 0,        }    }} impl From<&MimeBundle> for OutputType {    fn from(data: &MimeBundle) -> Self {        match data.richest(rank_mime_type) {            Some(MimeType::Plain(text)) => OutputType::Plain(TerminalOutput::from(text)),            Some(MimeType::Markdown(text)) => OutputType::Plain(TerminalOutput::from(text)),            Some(MimeType::Png(data)) | Some(MimeType::Jpeg(data)) => match ImageView::from(data) {                Ok(view) => OutputType::Image(view),                Err(error) => OutputType::Message(format!("Failed to load image: {}", error)),            },            Some(MimeType::DataTable(data)) => OutputType::Table(TableView {                table: data.clone(),            }),            // Any other media types are not supported            _ => OutputType::Message("Unsupported media type".to_string()),        }    }} #[derive(Default)]pub enum ExecutionStatus {    #[default]    Unknown,    #[allow(unused)]    ConnectingToKernel,    Executing,    Finished,} pub struct ExecutionView {    pub outputs: Vec<OutputType>,    pub status: ExecutionStatus,} impl ExecutionView {    pub fn new(_cx: &mut ViewContext<Self>) -> Self {        Self {            outputs: Default::default(),            status: ExecutionStatus::Unknown,        }    }     /// Accept a Jupyter message belonging to this execution    pub fn push_message(&mut self, message: &JupyterMessageContent, cx: &mut ViewContext<Self>) {        let output: OutputType = match message {            JupyterMessageContent::ExecuteResult(result) => (&result.data).into(),            JupyterMessageContent::DisplayData(result) => (&result.data).into(),            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) {                    new_terminal                } else {                    cx.notify();                    return;                }            }            JupyterMessageContent::ErrorOutput(result) => {                let mut terminal = TerminalOutput::new();                terminal.append_text(&result.traceback.join("\n"));                 OutputType::ErrorOutput(ErrorView {                    ename: result.ename.clone(),                    evalue: result.evalue.clone(),                    traceback: terminal,                })            }            JupyterMessageContent::ExecuteReply(reply) => {                for payload in reply.payload.iter() {                    match payload {                        // Pager data comes in via `?` at the end of a statement in Python, used for showing documentation.                        // Some UI will show this as a popup. For ease of implementation, it's included as an output here.                        runtimelib::Payload::Page { data, .. } => {                            let output: OutputType = (data).into();                            self.outputs.push(output);                        }                         // Set next input adds text to the next cell. Not required to support.                        // However, this could be implemented by                        // runtimelib::Payload::SetNextInput { text, replace } => todo!(),                         // Not likely to be used in the context of Zed, where someone could just open the buffer themselves                        // runtimelib::Payload::EditMagic { filename, line_number } => todo!(),                         //                        // runtimelib::Payload::AskExit { keepkernel } => todo!(),                        _ => {}                    }                }                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                OutputType::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(OutputType::ClearOutputWaitMarker) = self.outputs.last() {            self.outputs.clear();        }         self.outputs.push(output);         cx.notify();    }     fn apply_terminal_text(&mut self, text: &str) -> Option<OutputType> {        if let Some(last_output) = self.outputs.last_mut() {            match last_output {                OutputType::Stream(last_stream) => {                    last_stream.append_text(text);                    // Don't need to add a new output, we already have a terminal output                    return None;                }                // Edge case note: a clear output marker                OutputType::ClearOutputWaitMarker => {                    // Edge case note: a clear output marker is handled by the caller                    // since we will return a new output at the end here as a new terminal output                }                // A different output type is "in the way", so we need to create a new output,                // which is the same as having no prior output                _ => {}            }        }         let mut new_terminal = TerminalOutput::new();        new_terminal.append_text(text);        Some(OutputType::Stream(new_terminal))    }     pub fn set_status(&mut self, status: ExecutionStatus, cx: &mut ViewContext<Self>) {        self.status = status;        cx.notify();    }} impl Render for ExecutionView {    fn render(&mut self, cx: &mut ViewContext<Self>) -> impl IntoElement {        if self.outputs.len() == 0 {            match self.status {                ExecutionStatus::ConnectingToKernel => {                    return div().child("Connecting to kernel...").into_any_element()                }                ExecutionStatus::Executing => {                    return div().child("Executing...").into_any_element()                }                ExecutionStatus::Finished => {                    return div().child(Icon::new(IconName::Check)).into_any_element()                }                ExecutionStatus::Unknown => return div().child("...").into_any_element(),            }        }         div()            .w_full()            .children(self.outputs.iter().filter_map(|output| output.render(cx)))            .into_any_element()    }} impl LineHeight for ExecutionView {    fn num_lines(&self, cx: &mut WindowContext) -> u8 {        if self.outputs.is_empty() {            return 1; // For the status message if outputs are not there        }         self.outputs            .iter()            .map(|output| output.num_lines(cx))            .fold(0, |acc, additional_height| {                acc.saturating_add(additional_height)            })    }} impl LineHeight for View<ExecutionView> {    fn num_lines(&self, cx: &mut WindowContext) -> u8 {        self.update(cx, |execution_view, cx| execution_view.num_lines(cx))    }}

Keyboard shortcuts

General

Show keyboard shortcuts
?
Focus the current search
/

Issues and pull requests

Open filters
f

Issues, pull requests and Inbox

Select next item
j↓
Select previous item
k↑
Open selected item
Enter
Dismiss filters or clear selection
Esc

Repository code

Go to file
t