summaryrefslogtreecommitdiff
path: root/cli/tools
diff options
context:
space:
mode:
Diffstat (limited to 'cli/tools')
-rw-r--r--cli/tools/coverage/mod.rs29
-rw-r--r--cli/tools/repl/channel.rs9
-rw-r--r--cli/tools/repl/editor.rs81
-rw-r--r--cli/tools/repl/mod.rs5
-rw-r--r--cli/tools/repl/session.rs148
5 files changed, 107 insertions, 165 deletions
diff --git a/cli/tools/coverage/mod.rs b/cli/tools/coverage/mod.rs
index 6177295a6..1c14859ea 100644
--- a/cli/tools/coverage/mod.rs
+++ b/cli/tools/coverage/mod.rs
@@ -43,34 +43,22 @@ impl CoverageCollector {
}
async fn enable_debugger(&mut self) -> Result<(), AnyError> {
- self
- .session
- .post_message::<()>("Debugger.enable", None)
- .await?;
+ self.session.post_message("Debugger.enable", None).await?;
Ok(())
}
async fn enable_profiler(&mut self) -> Result<(), AnyError> {
- self
- .session
- .post_message::<()>("Profiler.enable", None)
- .await?;
+ self.session.post_message("Profiler.enable", None).await?;
Ok(())
}
async fn disable_debugger(&mut self) -> Result<(), AnyError> {
- self
- .session
- .post_message::<()>("Debugger.disable", None)
- .await?;
+ self.session.post_message("Debugger.disable", None).await?;
Ok(())
}
async fn disable_profiler(&mut self) -> Result<(), AnyError> {
- self
- .session
- .post_message::<()>("Profiler.disable", None)
- .await?;
+ self.session.post_message("Profiler.disable", None).await?;
Ok(())
}
@@ -78,9 +66,10 @@ impl CoverageCollector {
&mut self,
parameters: StartPreciseCoverageParameters,
) -> Result<StartPreciseCoverageReturnObject, AnyError> {
+ let parameters_value = serde_json::to_value(parameters)?;
let return_value = self
.session
- .post_message("Profiler.startPreciseCoverage", Some(parameters))
+ .post_message("Profiler.startPreciseCoverage", Some(parameters_value))
.await?;
let return_object = serde_json::from_value(return_value)?;
@@ -93,7 +82,7 @@ impl CoverageCollector {
) -> Result<TakePreciseCoverageReturnObject, AnyError> {
let return_value = self
.session
- .post_message::<()>("Profiler.takePreciseCoverage", None)
+ .post_message("Profiler.takePreciseCoverage", None)
.await?;
let return_object = serde_json::from_value(return_value)?;
@@ -603,8 +592,8 @@ pub async fn cover_files(
})?
};
let file = maybe_file.ok_or_else(|| {
- anyhow!("Failed to fetch \"{}\" from cache.
- Before generating coverage report, run `deno test --coverage` to ensure consistent state.",
+ anyhow!("Failed to fetch \"{}\" from cache.
+ Before generating coverage report, run `deno test --coverage` to ensure consistent state.",
module_specifier
)
})?;
diff --git a/cli/tools/repl/channel.rs b/cli/tools/repl/channel.rs
index 4f2086fb5..7cc802905 100644
--- a/cli/tools/repl/channel.rs
+++ b/cli/tools/repl/channel.rs
@@ -2,7 +2,6 @@
use deno_core::anyhow::anyhow;
use deno_core::error::AnyError;
-use deno_core::serde_json;
use deno_core::serde_json::Value;
use std::cell::RefCell;
use tokio::sync::mpsc::channel;
@@ -56,19 +55,17 @@ pub struct RustylineSyncMessageSender {
}
impl RustylineSyncMessageSender {
- pub fn post_message<T: serde::Serialize>(
+ pub fn post_message(
&self,
method: &str,
- params: Option<T>,
+ params: Option<Value>,
) -> Result<Value, AnyError> {
if let Err(err) =
self
.message_tx
.blocking_send(RustylineSyncMessage::PostMessage {
method: method.to_string(),
- params: params
- .map(|params| serde_json::to_value(params))
- .transpose()?,
+ params,
})
{
Err(anyhow!("{}", err))
diff --git a/cli/tools/repl/editor.rs b/cli/tools/repl/editor.rs
index 8a327f624..30b9fba87 100644
--- a/cli/tools/repl/editor.rs
+++ b/cli/tools/repl/editor.rs
@@ -1,13 +1,13 @@
// Copyright 2018-2022 the Deno authors. All rights reserved. MIT license.
-use crate::cdp;
use crate::colors;
use deno_ast::swc::parser::error::SyntaxError;
use deno_ast::swc::parser::token::Token;
use deno_ast::swc::parser::token::Word;
use deno_core::error::AnyError;
use deno_core::parking_lot::Mutex;
-use deno_core::serde_json;
+use deno_core::serde_json::json;
+use deno_core::serde_json::Value;
use rustyline::completion::Completer;
use rustyline::error::ReadlineError;
use rustyline::highlight::Highlighter;
@@ -39,14 +39,20 @@ impl EditorHelper {
.sync_sender
.post_message(
"Runtime.globalLexicalScopeNames",
- Some(cdp::GlobalLexicalScopeNamesArgs {
- execution_context_id: Some(self.context_id),
- }),
+ Some(json!({
+ "executionContextId": self.context_id,
+ })),
)
.unwrap();
- let evaluate_response: cdp::GlobalLexicalScopeNamesResponse =
- serde_json::from_value(evaluate_response).unwrap();
- evaluate_response.names
+
+ evaluate_response
+ .get("names")
+ .unwrap()
+ .as_array()
+ .unwrap()
+ .iter()
+ .map(|n| n.as_str().unwrap().to_string())
+ .collect()
}
pub fn get_expression_property_names(&self, expr: &str) -> Vec<String> {
@@ -75,8 +81,11 @@ impl EditorHelper {
fn get_expression_type(&self, expr: &str) -> Option<String> {
self
- .evaluate_expression(expr)
- .map(|res| res.result.kind.to_string())
+ .evaluate_expression(expr)?
+ .get("result")?
+ .get("type")?
+ .as_str()
+ .map(|s| s.to_string())
}
fn get_object_expr_properties(
@@ -84,60 +93,44 @@ impl EditorHelper {
object_expr: &str,
) -> Option<Vec<String>> {
let evaluate_result = self.evaluate_expression(object_expr)?;
- let object_id = evaluate_result.result.object_id?;
+ let object_id = evaluate_result.get("result")?.get("objectId")?;
let get_properties_response = self
.sync_sender
.post_message(
"Runtime.getProperties",
- Some(cdp::GetPropertiesArgs {
- object_id,
- own_properties: None,
- accessor_properties_only: None,
- generate_preview: None,
- non_indexed_properties_only: None,
- }),
+ Some(json!({
+ "objectId": object_id,
+ })),
)
.ok()?;
- let get_properties_response: cdp::GetPropertiesResponse =
- serde_json::from_value(get_properties_response).ok()?;
+
Some(
get_properties_response
- .result
- .into_iter()
- .map(|prop| prop.name)
+ .get("result")?
+ .as_array()
+ .unwrap()
+ .iter()
+ .map(|r| r.get("name").unwrap().as_str().unwrap().to_string())
.collect(),
)
}
- fn evaluate_expression(&self, expr: &str) -> Option<cdp::EvaluateResponse> {
+ fn evaluate_expression(&self, expr: &str) -> Option<Value> {
let evaluate_response = self
.sync_sender
.post_message(
"Runtime.evaluate",
- Some(cdp::EvaluateArgs {
- expression: expr.to_string(),
- object_group: None,
- include_command_line_api: None,
- silent: None,
- context_id: Some(self.context_id),
- return_by_value: None,
- generate_preview: None,
- user_gesture: None,
- await_promise: None,
- throw_on_side_effect: Some(true),
- timeout: Some(200),
- disable_breaks: None,
- repl_mode: None,
- allow_unsafe_eval_blocked_by_csp: None,
- unique_context_id: None,
- }),
+ Some(json!({
+ "contextId": self.context_id,
+ "expression": expr,
+ "throwOnSideEffect": true,
+ "timeout": 200,
+ })),
)
.ok()?;
- let evaluate_response: cdp::EvaluateResponse =
- serde_json::from_value(evaluate_response).ok()?;
- if evaluate_response.exception_details.is_some() {
+ if evaluate_response.get("exceptionDetails").is_some() {
None
} else {
Some(evaluate_response)
diff --git a/cli/tools/repl/mod.rs b/cli/tools/repl/mod.rs
index b49c641c4..0c9fdbfb0 100644
--- a/cli/tools/repl/mod.rs
+++ b/cli/tools/repl/mod.rs
@@ -33,7 +33,10 @@ async fn read_line_and_poll(
}
result = message_handler.recv() => {
match result {
- Some(RustylineSyncMessage::PostMessage { method, params }) => {
+ Some(RustylineSyncMessage::PostMessage {
+ method,
+ params
+ }) => {
let result = repl_session
.post_message_with_event_loop(&method, params)
.await;
diff --git a/cli/tools/repl/session.rs b/cli/tools/repl/session.rs
index 57109eb1d..5d458189f 100644
--- a/cli/tools/repl/session.rs
+++ b/cli/tools/repl/session.rs
@@ -1,13 +1,12 @@
// Copyright 2018-2022 the Deno authors. All rights reserved. MIT license.
-use crate::cdp;
use crate::colors;
use crate::lsp::ReplLanguageServer;
use deno_ast::DiagnosticsError;
use deno_ast::ImportsNotUsedAsValues;
use deno_core::error::AnyError;
use deno_core::futures::FutureExt;
-use deno_core::serde_json;
+use deno_core::serde_json::json;
use deno_core::serde_json::Value;
use deno_core::LocalInspectorSession;
use deno_runtime::worker::MainWorker;
@@ -59,7 +58,7 @@ impl std::fmt::Display for EvaluationOutput {
struct TsEvaluateResponse {
ts_code: String,
- value: cdp::EvaluateResponse,
+ value: Value,
}
pub struct ReplSession {
@@ -76,9 +75,7 @@ impl ReplSession {
worker
.with_event_loop(
- session
- .post_message::<()>("Runtime.enable", None)
- .boxed_local(),
+ session.post_message("Runtime.enable", None).boxed_local(),
)
.await?;
@@ -118,8 +115,9 @@ impl ReplSession {
let closed = self
.evaluate_expression("(this.closed)")
.await?
- .result
- .value
+ .get("result")
+ .unwrap()
+ .get("value")
.unwrap()
.as_bool()
.unwrap();
@@ -127,10 +125,10 @@ impl ReplSession {
Ok(closed)
}
- pub async fn post_message_with_event_loop<T: serde::Serialize>(
+ pub async fn post_message_with_event_loop(
&mut self,
method: &str,
- params: Option<T>,
+ params: Option<Value>,
) -> Result<Value, AnyError> {
self
.worker
@@ -158,24 +156,23 @@ impl ReplSession {
match self.evaluate_line_with_object_wrapping(line).await {
Ok(evaluate_response) => {
- let cdp::EvaluateResponse {
- result,
- exception_details,
- } = evaluate_response.value;
+ let evaluate_result = evaluate_response.value.get("result").unwrap();
+ let evaluate_exception_details =
+ evaluate_response.value.get("exceptionDetails");
- if exception_details.is_some() {
- self.set_last_thrown_error(&result).await?;
+ if evaluate_exception_details.is_some() {
+ self.set_last_thrown_error(evaluate_result).await?;
} else {
self
.language_server
.commit_text(&evaluate_response.ts_code)
.await;
- self.set_last_eval_result(&result).await?;
+ self.set_last_eval_result(evaluate_result).await?;
}
- let value = self.get_eval_value(&result).await?;
- Ok(match exception_details {
+ let value = self.get_eval_value(evaluate_result).await?;
+ Ok(match evaluate_exception_details {
Some(_) => EvaluationOutput::Error(format!("Uncaught {}", value)),
None => EvaluationOutput::Value(value),
})
@@ -227,7 +224,7 @@ impl ReplSession {
.as_ref()
.unwrap()
.value
- .exception_details
+ .get("exceptionDetails")
.is_some())
{
self.evaluate_ts_expression(line).await
@@ -238,90 +235,66 @@ impl ReplSession {
async fn set_last_thrown_error(
&mut self,
- error: &cdp::RemoteObject,
+ error: &Value,
) -> Result<(), AnyError> {
self.post_message_with_event_loop(
"Runtime.callFunctionOn",
- Some(cdp::CallFunctionOnArgs {
- function_declaration: "function (object) { Deno[Deno.internal].lastThrownError = object; }".to_string(),
- object_id: None,
- arguments: Some(vec![error.into()]),
- silent: None,
- return_by_value: None,
- generate_preview: None,
- user_gesture: None,
- await_promise: None,
- execution_context_id: Some(self.context_id),
- object_group: None,
- throw_on_side_effect: None
- }),
+ Some(json!({
+ "executionContextId": self.context_id,
+ "functionDeclaration": "function (object) { Deno[Deno.internal].lastThrownError = object; }",
+ "arguments": [
+ error,
+ ],
+ })),
).await?;
Ok(())
}
async fn set_last_eval_result(
&mut self,
- evaluate_result: &cdp::RemoteObject,
+ evaluate_result: &Value,
) -> Result<(), AnyError> {
- self
- .post_message_with_event_loop(
- "Runtime.callFunctionOn",
- Some(cdp::CallFunctionOnArgs {
- function_declaration:
- "function (object) { Deno[Deno.internal].lastEvalResult = object; }"
- .to_string(),
- object_id: None,
- arguments: Some(vec![evaluate_result.into()]),
- silent: None,
- return_by_value: None,
- generate_preview: None,
- user_gesture: None,
- await_promise: None,
- execution_context_id: Some(self.context_id),
- object_group: None,
- throw_on_side_effect: None,
- }),
- )
- .await?;
+ self.post_message_with_event_loop(
+ "Runtime.callFunctionOn",
+ Some(json!({
+ "executionContextId": self.context_id,
+ "functionDeclaration": "function (object) { Deno[Deno.internal].lastEvalResult = object; }",
+ "arguments": [
+ evaluate_result,
+ ],
+ })),
+ ).await?;
Ok(())
}
pub async fn get_eval_value(
&mut self,
- evaluate_result: &cdp::RemoteObject,
+ evaluate_result: &Value,
) -> Result<String, AnyError> {
// TODO(caspervonb) we should investigate using previews here but to keep things
// consistent with the previous implementation we just get the preview result from
// Deno.inspectArgs.
let inspect_response = self.post_message_with_event_loop(
"Runtime.callFunctionOn",
- Some(cdp::CallFunctionOnArgs {
- function_declaration: r#"function (object) {
+ Some(json!({
+ "executionContextId": self.context_id,
+ "functionDeclaration": r#"function (object) {
try {
return Deno[Deno.internal].inspectArgs(["%o", object], { colors: !Deno.noColor });
} catch (err) {
return Deno[Deno.internal].inspectArgs(["%o", err]);
}
- }"#.to_string(),
- object_id: None,
- arguments: Some(vec![evaluate_result.into()]),
- silent: None,
- return_by_value: None,
- generate_preview: None,
- user_gesture: None,
- await_promise: None,
- execution_context_id: Some(self.context_id),
- object_group: None,
- throw_on_side_effect: None
- }),
+ }"#,
+ "arguments": [
+ evaluate_result,
+ ],
+ })),
).await?;
- let response: cdp::CallFunctionOnResponse =
- serde_json::from_value(inspect_response)?;
- let value = response.result.value.unwrap();
- let s = value.as_str().unwrap();
+ let inspect_result = inspect_response.get("result").unwrap();
+ let value = inspect_result.get("value").unwrap().as_str().unwrap();
- Ok(s.to_string())
+ Ok(value.to_string())
}
async fn evaluate_ts_expression(
@@ -371,29 +344,16 @@ impl ReplSession {
async fn evaluate_expression(
&mut self,
expression: &str,
- ) -> Result<cdp::EvaluateResponse, AnyError> {
+ ) -> Result<Value, AnyError> {
self
.post_message_with_event_loop(
"Runtime.evaluate",
- Some(cdp::EvaluateArgs {
- expression: expression.to_string(),
- object_group: None,
- include_command_line_api: None,
- silent: None,
- context_id: Some(self.context_id),
- return_by_value: None,
- generate_preview: None,
- user_gesture: None,
- await_promise: None,
- throw_on_side_effect: None,
- timeout: None,
- disable_breaks: None,
- repl_mode: Some(true),
- allow_unsafe_eval_blocked_by_csp: None,
- unique_context_id: None,
- }),
+ Some(json!({
+ "expression": expression,
+ "contextId": self.context_id,
+ "replMode": true,
+ })),
)
.await
- .and_then(|res| serde_json::from_value(res).map_err(|e| e.into()))
}
}
generated by cgit v1.2.3 (git 2.25.1) at 2025-06-27 07:27:43 +0000