Evaluate expressions (#50)

* Introducing Eval (i to edit)

* Parse eval response

* Eval evals and prints

Author: dantleech

src/app.rs

@@ -10,6 +10,7 @@ use crate::event::input::AppEvent;
 use crate::notification::Notification;
 use crate::theme::Scheme;
 use crate::theme::Theme;
+use crate::view::eval::draw_properties;
 use crate::view::help::HelpView;
 use crate::view::layout::LayoutView;
 use crate::view::listen::ListenView;
@@ -27,6 +28,7 @@ use ratatui::layout::Rect;
 use ratatui::prelude::CrosstermBackend;
 use ratatui::style::Color;
 use ratatui::style::Style;
+use ratatui::text::Line;
 use ratatui::widgets::Block;
 use ratatui::widgets::Padding;
 use ratatui::widgets::Paragraph;
@@ -216,7 +218,7 @@ pub struct App {
     pub counter: u16,
 
     pub snapshot_notify: Arc<Notify>,
-    pub context_depth: u8,
+    pub context_depth: u16,
     pub theme: Theme,
 
     pub analyzed_files: AnalyzedFiles,
@@ -288,7 +290,7 @@ impl App {
                             Ok(_) => (),
                             Err(e) => error!(
                                 "Could not send connection event: {}",
-                                e.to_string()
+                                e
                             ),
                         }
                     }
@@ -434,8 +436,8 @@ impl App {
                 self.exec_continuation(AppEvent::Run).await;
             }
             AppEvent::ContextDepth(inc) => {
-                let depth = self.context_depth as i8;
-                self.context_depth = depth.wrapping_add(inc).max(0) as u8;
+                let depth = self.context_depth;
+                self.context_depth = depth.wrapping_add(inc as u16).max(0);
                 self.client
                     .lock()
                     .await
@@ -490,6 +492,28 @@ impl App {
                     .await?;
             }
             AppEvent::PushInputPlurality(char) => self.input_plurality.push(char),
+            AppEvent::EvalStart => {
+                self.session_view.eval_state.active = true;
+                self.focus_view = true;
+            },
+            AppEvent::EvalCancel => {
+                self.session_view.eval_state.active = false;
+                self.focus_view = false;
+            },
+            AppEvent::EvalExecute => {
+                self.session_view.eval_state.active = false;
+                self.focus_view = false;
+                let response = self.client
+                    .lock()
+                    .await
+                    .eval(
+                        self.session_view.eval_state.input.to_string(),
+                        self.session_view.stack_depth()
+                    )
+                    .await?;
+
+                self.session_view.eval_state.properties = response.properties;
+            },
             AppEvent::Input(key_event) => {
                 if self.focus_view {
                     // event shandled exclusively by view (e.g. input needs focus)
@@ -654,7 +678,7 @@ impl App {
         if !self.history.is_current() {
             return Ok(());
         }
-        let level = self.session_view.stack_scroll.0 as usize;
+        let level = self.session_view.stack_level();
         if let Some(c) = self.history.current_mut() {
             let stack = c.stacks.get_mut(level);
             if let Some(s) = stack {

src/dbgp/client.rs

@@ -31,6 +31,13 @@ pub enum CommandResponse {
     StackGet(StackGetResponse),
     Source(String),
     ContextGet(ContextGetResponse),
+    Eval(EvalResponse),
+}
+
+#[derive(Debug, Clone, PartialEq)]
+pub struct DbgpError {
+    pub message: String,
+    pub code: String,
 }
 
 #[derive(Debug, Clone, PartialEq)]
@@ -135,6 +142,13 @@ pub struct ContinuationResponse {
     pub reason: String,
 }
 
+#[derive(Debug, Clone, PartialEq)]
+pub struct EvalResponse {
+    pub success: bool,
+    pub error: Option<DbgpError>,
+    pub properties: Vec<Property>,
+}
+
 #[derive(Debug, Clone)]
 pub struct StackGetResponse {
     pub entries: Vec<StackEntry>,
@@ -244,6 +258,17 @@ impl DbgpClient {
         }
     }
 
+    pub(crate) async fn eval(&mut self, expression: String, depth: u16) -> Result<EvalResponse> {
+        let base64 = general_purpose::STANDARD.encode(expression.as_bytes());
+        match self.command("eval", &mut ["-d", format!("{}", depth).as_str(), "--", &base64]).await? {
+            Message::Response(r) => match r.command {
+                CommandResponse::Eval(s) => Ok(s),
+                _ => anyhow::bail!("Unexpected response"),
+            },
+            _ => anyhow::bail!("Unexpected response"),
+        }
+    }
+
     pub(crate) async fn step_into(&mut self) -> Result<ContinuationResponse> {
         match self.command("step_into", &mut []).await? {
             Message::Response(r) => match r.command {
@@ -368,6 +393,7 @@ fn parse_xml(xml: &str) -> Result<Message, anyhow::Error> {
                 "stack_get" => CommandResponse::StackGet(parse_stack_get(&root)),
                 "source" => CommandResponse::Source(parse_source(&root)?),
                 "context_get" => CommandResponse::ContextGet(parse_context_get(&mut root)?),
+                "eval" => CommandResponse::Eval(parse_eval(&mut root)?),
                 _ => CommandResponse::Unknown,
             },
         })),
@@ -377,13 +403,40 @@ fn parse_xml(xml: &str) -> Result<Message, anyhow::Error> {
 fn parse_source(element: &Element) -> Result<String, anyhow::Error> {
     match element.children.first() {
         Some(XMLNode::CData(e)) => {
-            Ok(String::from_utf8(general_purpose::STANDARD.decode(e).unwrap()).unwrap())
+            Ok(String::from_utf8(general_purpose::STANDARD.decode(e)?)?)
         }
         _ => anyhow::bail!("Expected CDATA"),
     }
 }
 
+
 fn parse_context_get(element: &mut Element) -> Result<ContextGetResponse, anyhow::Error> {
+    Ok(ContextGetResponse { properties: parse_properties(element)?})
+}
+
+fn parse_eval(element: &mut Element) -> Result<EvalResponse, anyhow::Error> {
+
+    let error = if let Some(mut error_el) = element.take_child("error") {
+        let code = error_el.attributes.get("code").map_or("".to_string(), |v|v.to_string());
+        let message = match error_el.take_child("message") {
+            Some(m) => match m.children.first() {
+                Some(XMLNode::CData(e)) => {
+                    e.to_string()
+                },
+                _ => String::new(),
+            },
+            _ => "".to_string()
+        };
+        
+        Some(DbgpError{message, code: code.to_string()})
+    } else {
+        None
+    };
+
+    Ok(EvalResponse { success: true, properties: parse_properties(element)?, error })
+}
+
+fn parse_properties(element: &mut Element) -> Result<Vec<Property>, anyhow::Error> {
     let mut properties: Vec<Property> = vec![];
     while let Some(mut child) = element.take_child("property") {
         let encoding = child.attributes.get("encoding").map(|s| s.to_string());
@@ -428,12 +481,12 @@ fn parse_context_get(element: &mut Element) -> Result<ContextGetResponse, anyhow
             key: child.attributes.get("key").map(|name| name.to_string()),
             address: child.attributes.get("address").map(|name| name.to_string()),
             encoding: encoding.clone(),
-            children: parse_context_get(&mut child).unwrap().properties,
+            children: parse_properties(&mut child)?,
             value: decode_element(Some(&child)),
         };
         properties.push(p);
     }
-    Ok(ContextGetResponse { properties })
+    Ok(properties)
 }
 
 fn decode_element(element: Option<&Element>) -> Option<String> {
@@ -601,6 +654,79 @@ function call_function(string $hello) {
         Ok(())
     }
 
+    #[test]
+    fn test_parse_eval() -> Result<(), anyhow::Error> {
+        let result = parse_xml(
+            r#"
+            <response xmlns="urn:debugger_protocol_v1" xmlns:xdebug="https://xdebug.org/dbgp/xdebug" command="eval" transaction_id="28"><property type="int"><![CDATA[2]]></property></response>
+            "#,
+        )?;
+
+        match result {
+            Message::Response(r) => {
+                match r.command {
+                    CommandResponse::Eval(response) => {
+                        let expected = EvalResponse {
+                            success: true,
+                            error: None,
+                            properties: vec![
+                                Property {
+                                    name: "".to_string(),
+                                    fullname: "".to_string(),
+                                    classname: None,
+                                    page: None,
+                                    pagesize: None,
+                                    property_type: PropertyType::Int,
+                                    facet: None,
+                                    size: None,
+                                    children: vec![],
+                                    key: None,
+                                    address: None,
+                                    encoding: None,
+                                    value: Some(2.to_string()),
+                                },
+                            ],
+                        };
+                        assert_eq!(expected, response)
+                    }
+                    _ => panic!("Could not parse context_get"),
+                };
+            }
+            _ => panic!("Did not parse"),
+        };
+        Ok(())
+    }
+
+    #[test]
+    fn test_parse_eval_error() -> Result<(), anyhow::Error> {
+        let result = parse_xml(
+            r#"
+            <response xmlns="urn:debugger_protocol_v1" xmlns:xdebug="https://xdebug.org/dbgp/xdebug" command="eval" transaction_id="6" status="break" reason="ok"><error code="206"><message><![CDATA[error evaluating code: Undefined constant "asda"]]></message></error></response>
+            "#,
+        )?;
+
+        match result {
+            Message::Response(r) => {
+                match r.command {
+                    CommandResponse::Eval(response) => {
+                        let expected = EvalResponse {
+                            success: true,
+                            error: Some(DbgpError {
+                                message: "error evaluating code: Undefined constant \"asda\"".to_string(),
+                                code: "206".to_string()
+                            }),
+                            properties: vec![],
+                        };
+                        assert_eq!(expected, response)
+                    }
+                    _ => panic!("Could not parse context_get"),
+                };
+            }
+            _ => panic!("Did not parse"),
+        };
+        Ok(())
+    }
+
     #[test]
     fn test_parse_context_get() -> Result<(), anyhow::Error> {
         let result = parse_xml(

src/event/input.rs

@@ -50,6 +50,9 @@ pub enum AppEvent {
     ContextFilterOpen,
     ContextSearchClose,
     Listen,
+    EvalCancel,
+    EvalExecute,
+    EvalStart,
 }
 
 pub type EventSender = Sender<AppEvent>;