471 lines · 17.1 KB · Rust
RawDownload
use crate::{    jupyter_settings::{JupyterDockPosition, JupyterSettings},    kernels::{kernel_specifications, KernelSpecification},    session::{Session, SessionEvent},};use anyhow::{Context as _, Result};use collections::HashMap;use editor::{Anchor, Editor, RangeToAnchorExt};use futures::StreamExt as _;use gpui::{    actions, prelude::*, AppContext, AsyncWindowContext, EntityId, EventEmitter, FocusHandle,    FocusOutEvent, FocusableView, Subscription, Task, View, WeakView,};use language::Point;use project::Fs;use settings::{Settings as _, SettingsStore};use std::{ops::Range, sync::Arc};use ui::{prelude::*, ButtonLike, ElevationIndex, KeyBinding};use util::ResultExt as _;use workspace::{    dock::{Panel, PanelEvent},    Workspace,}; actions!(repl, [Run, ClearOutputs]);actions!(repl_panel, [ToggleFocus]); pub fn init(cx: &mut AppContext) {    cx.observe_new_views(        |workspace: &mut Workspace, _cx: &mut ViewContext<Workspace>| {            workspace.register_action(|workspace, _: &ToggleFocus, cx| {                workspace.toggle_panel_focus::<RuntimePanel>(cx);            });        },    )    .detach();} pub struct RuntimePanel {    fs: Arc<dyn Fs>,    enabled: bool,    focus_handle: FocusHandle,    width: Option<Pixels>,    sessions: HashMap<EntityId, View<Session>>,    kernel_specifications: Vec<KernelSpecification>,    _subscriptions: Vec<Subscription>,    _editor_events_task: Task<()>,} pub enum ReplEvent {    Run(WeakView<Editor>),    ClearOutputs(WeakView<Editor>),} impl RuntimePanel {    pub fn load(        workspace: WeakView<Workspace>,        cx: AsyncWindowContext,    ) -> Task<Result<View<Self>>> {        cx.spawn(|mut cx| async move {            let view = workspace.update(&mut cx, |workspace, cx| {                cx.new_view::<Self>(|cx| {                    let focus_handle = cx.focus_handle();                     let fs = workspace.app_state().fs.clone();                     // Make a channel that we receive editor events on (for repl::Run, repl::ClearOutputs)                    // This allows us to inject actions on the editor from the repl panel without requiring the editor to                    // depend on the `repl` crate.                    let (repl_editor_event_tx, mut repl_editor_event_rx) =                        futures::channel::mpsc::unbounded::<ReplEvent>();                     let subscriptions = vec![                        cx.on_focus_in(&focus_handle, Self::focus_in),                        cx.on_focus_out(&focus_handle, Self::focus_out),                        cx.observe_global::<SettingsStore>(move |this, cx| {                            this.set_enabled(JupyterSettings::enabled(cx), cx);                        }),                        cx.observe_new_views(                            move |editor: &mut Editor, cx: &mut ViewContext<Editor>| {                                let editor_view = cx.view().downgrade();                                let run_event_tx = repl_editor_event_tx.clone();                                let clear_event_tx = repl_editor_event_tx.clone();                                editor                                    .register_action(move |_: &Run, cx: &mut WindowContext| {                                        if !JupyterSettings::enabled(cx) {                                            return;                                        }                                        run_event_tx                                            .unbounded_send(ReplEvent::Run(editor_view.clone()))                                            .ok();                                    })                                    .detach();                                 let editor_view = cx.view().downgrade();                                editor                                    .register_action(                                        move |_: &ClearOutputs, cx: &mut WindowContext| {                                            if !JupyterSettings::enabled(cx) {                                                return;                                            }                                            clear_event_tx                                                .unbounded_send(ReplEvent::ClearOutputs(                                                    editor_view.clone(),                                                ))                                                .ok();                                        },                                    )                                    .detach();                            },                        ),                    ];                     // Listen for events from the editor on the `repl_editor_event_rx` channel                    let _editor_events_task = cx.spawn(                        move |this: WeakView<RuntimePanel>, mut cx: AsyncWindowContext| async move {                            while let Some(event) = repl_editor_event_rx.next().await {                                this.update(&mut cx, |runtime_panel, cx| match event {                                    ReplEvent::Run(editor) => {                                        runtime_panel.run(editor, cx).log_err();                                    }                                    ReplEvent::ClearOutputs(editor) => {                                        runtime_panel.clear_outputs(editor, cx);                                    }                                })                                .ok();                            }                        },                    );                     let runtime_panel = Self {                        fs: fs.clone(),                        width: None,                        focus_handle,                        kernel_specifications: Vec::new(),                        sessions: Default::default(),                        _subscriptions: subscriptions,                        enabled: JupyterSettings::enabled(cx),                        _editor_events_task,                    };                     runtime_panel                })            })?;             view.update(&mut cx, |this, cx| this.refresh_kernelspecs(cx))?                .await?;             Ok(view)        })    }     fn set_enabled(&mut self, enabled: bool, cx: &mut ViewContext<Self>) {        if self.enabled != enabled {            self.enabled = enabled;            cx.notify();        }    }     fn focus_in(&mut self, cx: &mut ViewContext<Self>) {        cx.notify();    }     fn focus_out(&mut self, _event: FocusOutEvent, cx: &mut ViewContext<Self>) {        cx.notify();    }     // Gets the active selection in the editor or the current line    fn selection(&self, editor: View<Editor>, cx: &mut ViewContext<Self>) -> Range<Anchor> {        let editor = editor.read(cx);        let selection = editor.selections.newest::<usize>(cx);        let multi_buffer_snapshot = editor.buffer().read(cx).snapshot(cx);         let range = if selection.is_empty() {            let cursor = selection.head();             let line_start = multi_buffer_snapshot.offset_to_point(cursor).row;            let mut start_offset = multi_buffer_snapshot.point_to_offset(Point::new(line_start, 0));             // Iterate backwards to find the start of the line            while start_offset > 0 {                let ch = multi_buffer_snapshot                    .chars_at(start_offset - 1)                    .next()                    .unwrap_or('\0');                if ch == '\n' {                    break;                }                start_offset -= 1;            }             let mut end_offset = cursor;             // Iterate forwards to find the end of the line            while end_offset < multi_buffer_snapshot.len() {                let ch = multi_buffer_snapshot                    .chars_at(end_offset)                    .next()                    .unwrap_or('\0');                if ch == '\n' {                    break;                }                end_offset += 1;            }             // Create a range from the start to the end of the line            start_offset..end_offset        } else {            selection.range()        };         range.to_anchors(&multi_buffer_snapshot)    }     pub fn snippet(        &self,        editor: WeakView<Editor>,        cx: &mut ViewContext<Self>,    ) -> Option<(String, Arc<str>, Range<Anchor>)> {        let editor = editor.upgrade()?;         let buffer = editor.read(cx).buffer().read(cx).snapshot(cx);        let anchor_range = self.selection(editor, cx);         let selected_text = buffer            .text_for_range(anchor_range.clone())            .collect::<String>();         let start_language = buffer.language_at(anchor_range.start);        let end_language = buffer.language_at(anchor_range.end);         let language_name = if start_language == end_language {            start_language                .map(|language| language.code_fence_block_name())                .filter(|lang| **lang != *"markdown")?        } else {            // If the selection spans multiple languages, don't run it            return None;        };         Some((selected_text, language_name, anchor_range))    }     pub fn refresh_kernelspecs(&mut self, cx: &mut ViewContext<Self>) -> Task<anyhow::Result<()>> {        let kernel_specifications = kernel_specifications(self.fs.clone());        cx.spawn(|this, mut cx| async move {            let kernel_specifications = kernel_specifications.await?;             this.update(&mut cx, |this, cx| {                this.kernel_specifications = kernel_specifications;                cx.notify();            })        })    }     pub fn kernelspec(        &self,        language_name: &str,        cx: &mut ViewContext<Self>,    ) -> Option<KernelSpecification> {        let settings = JupyterSettings::get_global(cx);        let selected_kernel = settings.kernel_selections.get(language_name);         self.kernel_specifications            .iter()            .find(|runtime_specification| {                if let Some(selected) = selected_kernel {                    // Top priority is the selected kernel                    runtime_specification.name.to_lowercase() == selected.to_lowercase()                } else {                    // Otherwise, we'll try to find a kernel that matches the language                    runtime_specification.kernelspec.language.to_lowercase()                        == language_name.to_lowercase()                }            })            .cloned()    }     pub fn run(        &mut self,        editor: WeakView<Editor>,        cx: &mut ViewContext<Self>,    ) -> anyhow::Result<()> {        if !self.enabled {            return Ok(());        }         let (selected_text, language_name, anchor_range) = match self.snippet(editor.clone(), cx) {            Some(snippet) => snippet,            None => return Ok(()),        };         let entity_id = editor.entity_id();         let kernel_specification = self            .kernelspec(&language_name, cx)            .with_context(|| format!("No kernel found for language: {language_name}"))?;         let session = self.sessions.entry(entity_id).or_insert_with(|| {            let view =                cx.new_view(|cx| Session::new(editor, self.fs.clone(), kernel_specification, cx));            cx.notify();             let subscription = cx.subscribe(                &view,                |panel: &mut RuntimePanel, _session: View<Session>, event: &SessionEvent, _cx| {                    match event {                        SessionEvent::Shutdown(shutdown_event) => {                            panel.sessions.remove(&shutdown_event.entity_id());                        }                    }                    //                },            );             subscription.detach();             view        });         session.update(cx, |session, cx| {            session.execute(&selected_text, anchor_range, cx);        });         anyhow::Ok(())    }     pub fn clear_outputs(&mut self, editor: WeakView<Editor>, cx: &mut ViewContext<Self>) {        let entity_id = editor.entity_id();        if let Some(session) = self.sessions.get_mut(&entity_id) {            session.update(cx, |session, cx| {                session.clear_outputs(cx);            });            cx.notify();        }    }} impl Panel for RuntimePanel {    fn persistent_name() -> &'static str {        "RuntimePanel"    }     fn position(&self, cx: &ui::WindowContext) -> workspace::dock::DockPosition {        match JupyterSettings::get_global(cx).dock {            JupyterDockPosition::Left => workspace::dock::DockPosition::Left,            JupyterDockPosition::Right => workspace::dock::DockPosition::Right,            JupyterDockPosition::Bottom => workspace::dock::DockPosition::Bottom,        }    }     fn position_is_valid(&self, _position: workspace::dock::DockPosition) -> bool {        true    }     fn set_position(        &mut self,        position: workspace::dock::DockPosition,        cx: &mut ViewContext<Self>,    ) {        settings::update_settings_file::<JupyterSettings>(self.fs.clone(), cx, move |settings| {            let dock = match position {                workspace::dock::DockPosition::Left => JupyterDockPosition::Left,                workspace::dock::DockPosition::Right => JupyterDockPosition::Right,                workspace::dock::DockPosition::Bottom => JupyterDockPosition::Bottom,            };            settings.set_dock(dock);        })    }     fn size(&self, cx: &ui::WindowContext) -> Pixels {        let settings = JupyterSettings::get_global(cx);         self.width.unwrap_or(settings.default_width)    }     fn set_size(&mut self, size: Option<ui::Pixels>, _cx: &mut ViewContext<Self>) {        self.width = size;    }     fn icon(&self, _cx: &ui::WindowContext) -> Option<ui::IconName> {        if !self.enabled {            return None;        }         Some(IconName::Code)    }     fn icon_tooltip(&self, _cx: &ui::WindowContext) -> Option<&'static str> {        Some("Runtime Panel")    }     fn toggle_action(&self) -> Box<dyn gpui::Action> {        Box::new(ToggleFocus)    }} impl EventEmitter<PanelEvent> for RuntimePanel {} impl FocusableView for RuntimePanel {    fn focus_handle(&self, _cx: &AppContext) -> FocusHandle {        self.focus_handle.clone()    }} impl Render for RuntimePanel {    fn render(&mut self, cx: &mut ViewContext<Self>) -> impl IntoElement {        // When there are no kernel specifications, show a link to the Zed docs explaining how to        // install kernels. It can be assumed they don't have a running kernel if we have no        // specifications.        if self.kernel_specifications.is_empty() {            return v_flex()                .p_4()                .size_full()                .gap_2()                        .child(Label::new("No Jupyter Kernels Available").size(LabelSize::Large))                        .child(                            Label::new("To start interactively running code in your editor, you need to install and configure Jupyter kernels.")                                .size(LabelSize::Default),                        )                        .child(                            h_flex().w_full().p_4().justify_center().gap_2().child(                                ButtonLike::new("install-kernels")                                    .style(ButtonStyle::Filled)                                    .size(ButtonSize::Large)                                    .layer(ElevationIndex::ModalSurface)                                    .child(Label::new("Install Kernels"))                                    .on_click(move |_, cx| {                                        cx.open_url(                                        "https://docs.jupyter.org/en/latest/install/kernels.html",                                    )                                    }),                            ),                        )                .into_any_element();        }         // When there are no sessions, show the command to run code in an editor        if self.sessions.is_empty() {            return v_flex()                .p_4()                .size_full()                .gap_2()                .child(Label::new("No Jupyter Kernel Sessions").size(LabelSize::Large))                .child(                    v_flex().child(                        Label::new("To run code in a Jupyter kernel, select some code and use the 'repl::Run' command.")                            .size(LabelSize::Default)                    )                    .children(                            KeyBinding::for_action(&Run, cx)                            .map(|binding|                                binding.into_any_element()                            )                    )                )                 .into_any_element();        }         v_flex()            .p_4()            .child(Label::new("Jupyter Kernel Sessions").size(LabelSize::Large))            .children(                self.sessions                    .values()                    .map(|session| session.clone().into_any_element()),            )            .into_any_element()    }}

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