mirror of
https://github.com/denoland/deno.git
synced 2024-12-23 15:49:44 -05:00
504482dadd
Fixes #8858. Fixes #8869. ``` $ target/debug/deno Deno 1.32.5 exit using ctrl+d, ctrl+c, or close() REPL is running with all permissions allowed. To specify permissions, run `deno repl` with allow flags. > Promise.reject(new Error("bar")); Promise { <rejected> Error: bar at <anonymous>:2:16 } Uncaught (in promise) Error: bar at <anonymous>:2:16 > reportError(new Error("baz")); undefined Uncaught Error: baz at <anonymous>:2:13 >
212 lines
6.7 KiB
Rust
212 lines
6.7 KiB
Rust
// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
|
|
|
|
use crate::args::CliOptions;
|
|
use crate::args::Flags;
|
|
use crate::args::ReplFlags;
|
|
use crate::colors;
|
|
use crate::file_fetcher::FileFetcher;
|
|
use crate::proc_state::ProcState;
|
|
use deno_core::error::AnyError;
|
|
use deno_core::futures::StreamExt;
|
|
use deno_runtime::permissions::Permissions;
|
|
use deno_runtime::permissions::PermissionsContainer;
|
|
use rustyline::error::ReadlineError;
|
|
|
|
mod cdp;
|
|
mod channel;
|
|
mod editor;
|
|
mod session;
|
|
|
|
use channel::rustyline_channel;
|
|
use channel::RustylineSyncMessage;
|
|
use channel::RustylineSyncMessageHandler;
|
|
use channel::RustylineSyncResponse;
|
|
use editor::EditorHelper;
|
|
use editor::ReplEditor;
|
|
use session::EvaluationOutput;
|
|
use session::ReplSession;
|
|
|
|
async fn read_line_and_poll(
|
|
repl_session: &mut ReplSession,
|
|
message_handler: &mut RustylineSyncMessageHandler,
|
|
editor: ReplEditor,
|
|
) -> Result<String, ReadlineError> {
|
|
#![allow(clippy::await_holding_refcell_ref)]
|
|
let mut line_fut = tokio::task::spawn_blocking(move || editor.readline());
|
|
let mut poll_worker = true;
|
|
let notifications_rc = repl_session.notifications.clone();
|
|
let mut notifications = notifications_rc.borrow_mut();
|
|
|
|
loop {
|
|
tokio::select! {
|
|
result = &mut line_fut => {
|
|
return result.unwrap();
|
|
}
|
|
result = message_handler.recv() => {
|
|
match result {
|
|
Some(RustylineSyncMessage::PostMessage { method, params }) => {
|
|
let result = repl_session
|
|
.post_message_with_event_loop(&method, params)
|
|
.await;
|
|
message_handler.send(RustylineSyncResponse::PostMessage(result)).unwrap();
|
|
},
|
|
Some(RustylineSyncMessage::LspCompletions {
|
|
line_text,
|
|
position,
|
|
}) => {
|
|
let result = repl_session.language_server.completions(&line_text, position).await;
|
|
message_handler.send(RustylineSyncResponse::LspCompletions(result)).unwrap();
|
|
}
|
|
None => {}, // channel closed
|
|
}
|
|
|
|
poll_worker = true;
|
|
}
|
|
message = notifications.next() => {
|
|
if let Some(message) = message {
|
|
let method = message.get("method").unwrap().as_str().unwrap();
|
|
if method == "Runtime.exceptionThrown" {
|
|
let params = message.get("params").unwrap().as_object().unwrap();
|
|
let exception_details = params.get("exceptionDetails").unwrap().as_object().unwrap();
|
|
let text = exception_details.get("text").unwrap().as_str().unwrap();
|
|
let exception = exception_details.get("exception").unwrap().as_object().unwrap();
|
|
let description = exception.get("description").unwrap().as_str().unwrap();
|
|
println!("{text} {description}");
|
|
}
|
|
}
|
|
}
|
|
_ = repl_session.run_event_loop(), if poll_worker => {
|
|
poll_worker = false;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
async fn read_eval_file(
|
|
cli_options: &CliOptions,
|
|
file_fetcher: &FileFetcher,
|
|
eval_file: &str,
|
|
) -> Result<String, AnyError> {
|
|
let specifier =
|
|
deno_core::resolve_url_or_path(eval_file, cli_options.initial_cwd())?;
|
|
|
|
let file = file_fetcher
|
|
.fetch(&specifier, PermissionsContainer::allow_all())
|
|
.await?;
|
|
|
|
Ok((*file.source).to_string())
|
|
}
|
|
|
|
pub async fn run(flags: Flags, repl_flags: ReplFlags) -> Result<i32, AnyError> {
|
|
let ps = ProcState::from_flags(flags).await?;
|
|
let main_module = ps.options.resolve_main_module()?;
|
|
let permissions = PermissionsContainer::new(Permissions::from_options(
|
|
&ps.options.permissions_options(),
|
|
)?);
|
|
let cli_options = ps.options.clone();
|
|
let npm_resolver = ps.npm_resolver.clone();
|
|
let resolver = ps.resolver.clone();
|
|
let dir = ps.dir.clone();
|
|
let file_fetcher = ps.file_fetcher.clone();
|
|
let worker_factory = ps.into_cli_main_worker_factory();
|
|
|
|
let mut worker = worker_factory
|
|
.create_main_worker(main_module, permissions)
|
|
.await?;
|
|
worker.setup_repl().await?;
|
|
let worker = worker.into_main_worker();
|
|
let mut repl_session =
|
|
ReplSession::initialize(&cli_options, npm_resolver, resolver, worker)
|
|
.await?;
|
|
let mut rustyline_channel = rustyline_channel();
|
|
|
|
let helper = EditorHelper {
|
|
context_id: repl_session.context_id,
|
|
sync_sender: rustyline_channel.0,
|
|
};
|
|
|
|
let history_file_path = dir.repl_history_file_path();
|
|
let editor = ReplEditor::new(helper, history_file_path)?;
|
|
|
|
if let Some(eval_files) = repl_flags.eval_files {
|
|
for eval_file in eval_files {
|
|
match read_eval_file(&cli_options, &file_fetcher, &eval_file).await {
|
|
Ok(eval_source) => {
|
|
let output = repl_session
|
|
.evaluate_line_and_get_output(&eval_source)
|
|
.await;
|
|
// only output errors
|
|
if let EvaluationOutput::Error(error_text) = output {
|
|
println!("Error in --eval-file file \"{eval_file}\": {error_text}");
|
|
}
|
|
}
|
|
Err(e) => {
|
|
println!("Error in --eval-file file \"{eval_file}\": {e}");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if let Some(eval) = repl_flags.eval {
|
|
let output = repl_session.evaluate_line_and_get_output(&eval).await;
|
|
// only output errors
|
|
if let EvaluationOutput::Error(error_text) = output {
|
|
println!("Error in --eval flag: {error_text}");
|
|
}
|
|
}
|
|
|
|
// Doing this manually, instead of using `log::info!` because these messages
|
|
// are supposed to go to stdout, not stderr.
|
|
if !cli_options.is_quiet() {
|
|
println!("Deno {}", crate::version::deno());
|
|
println!("exit using ctrl+d, ctrl+c, or close()");
|
|
if repl_flags.is_default_command {
|
|
println!(
|
|
"{}",
|
|
colors::yellow("REPL is running with all permissions allowed.")
|
|
);
|
|
println!("To specify permissions, run `deno repl` with allow flags.")
|
|
}
|
|
}
|
|
|
|
loop {
|
|
let line = read_line_and_poll(
|
|
&mut repl_session,
|
|
&mut rustyline_channel.1,
|
|
editor.clone(),
|
|
)
|
|
.await;
|
|
match line {
|
|
Ok(line) => {
|
|
editor.set_should_exit_on_interrupt(false);
|
|
editor.update_history(line.clone());
|
|
let output = repl_session.evaluate_line_and_get_output(&line).await;
|
|
|
|
// We check for close and break here instead of making it a loop condition to get
|
|
// consistent behavior in when the user evaluates a call to close().
|
|
if repl_session.closing().await? {
|
|
break;
|
|
}
|
|
|
|
println!("{output}");
|
|
}
|
|
Err(ReadlineError::Interrupted) => {
|
|
if editor.should_exit_on_interrupt() {
|
|
break;
|
|
}
|
|
editor.set_should_exit_on_interrupt(true);
|
|
println!("press ctrl+c again to exit");
|
|
continue;
|
|
}
|
|
Err(ReadlineError::Eof) => {
|
|
break;
|
|
}
|
|
Err(err) => {
|
|
println!("Error: {err:?}");
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
Ok(repl_session.worker.exit_code())
|
|
}
|