support optional arguments in ?play

Author: tinaun

src/main.rs

@@ -112,12 +112,29 @@ fn app() -> Result<()> {
 
     if config.eval {
         // rust playground
-        cmds.add("?play ```\ncode```", playground::run);
-        cmds.add("?play code...", playground::help);
+        cmds.add(
+            "?play mode={} edition={} channel={} ```\ncode```",
+            playground::run,
+        );
+        cmds.add("?play code...", playground::err);
+        cmds.help(
+            "?play",
+            "Compile and run rust code in a playground",
+            |args| playground::help(args, "play"),
+        );
 
-        cmds.add("?eval ```\ncode```", playground::eval);
-        cmds.add("?eval `code`", playground::eval);
-        cmds.add("?eval code...", playground::eval_help);
+        cmds.add(
+            "?eval mode={} edition={} channel={} ```\ncode```",
+            playground::eval,
+        );
+        cmds.add(
+            "?eval mode={} edition={} channel={} `code`",
+            playground::eval,
+        );
+        cmds.add("?eval code...", playground::eval_err);
+        cmds.help("?eval", "Evaluate a single rust expression", |args| {
+            playground::help(args, "eval")
+        });
     }
 
     // Slow mode.

src/playground.rs

@@ -8,20 +8,21 @@ use crate::{
 use reqwest::header;
 use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
+use std::str::FromStr;
 
 #[derive(Debug, Serialize)]
-struct PlaygroundCode {
+struct PlaygroundCode<'a> {
     channel: Channel,
     edition: Edition,
-    code: String,
+    code: &'a str,
     #[serde(rename = "crateType")]
     crate_type: CrateType,
     mode: Mode,
     tests: bool,
 }
 
-impl PlaygroundCode {
-    fn new(code: String) -> Self {
+impl<'a> PlaygroundCode<'a> {
+    fn new(code: &'a str) -> Self {
         PlaygroundCode {
             channel: Channel::Nightly,
             edition: Edition::E2018,
@@ -64,6 +65,19 @@ enum Channel {
     Nightly,
 }
 
+impl FromStr for Channel {
+    type Err = Box<dyn std::error::Error>;
+
+    fn from_str(s: &str) -> Result<Self> {
+        match s {
+            "stable" => Ok(Channel::Stable),
+            "beta" => Ok(Channel::Beta),
+            "nightly" => Ok(Channel::Nightly),
+            _ => Err(format!("invalid release channel `{}`", s).into()),
+        }
+    }
+}
+
 #[derive(Debug, Serialize)]
 enum Edition {
     #[serde(rename = "2015")]
@@ -72,6 +86,18 @@ enum Edition {
     E2018,
 }
 
+impl FromStr for Edition {
+    type Err = Box<dyn std::error::Error>;
+
+    fn from_str(s: &str) -> Result<Self> {
+        match s {
+            "2015" => Ok(Edition::E2015),
+            "2018" => Ok(Edition::E2018),
+            _ => Err(format!("invalid edition `{}`", s).into()),
+        }
+    }
+}
+
 #[derive(Debug, Serialize)]
 enum CrateType {
     #[serde(rename = "bin")]
@@ -87,6 +113,18 @@ enum Mode {
     Release,
 }
 
+impl FromStr for Mode {
+    type Err = Box<dyn std::error::Error>;
+
+    fn from_str(s: &str) -> Result<Self> {
+        match s {
+            "debug" => Ok(Mode::Debug),
+            "release" => Ok(Mode::Release),
+            _ => Err(format!("invalid compilation mode `{}`", s).into()),
+        }
+    }
+}
+
 #[derive(Debug, Deserialize)]
 struct PlayResult {
     success: bool,
@@ -95,8 +133,32 @@ struct PlayResult {
 }
 
 fn run_code(args: &Args, code: &str) -> Result<String> {
-    info!("sending request to playground.");
-    let request = PlaygroundCode::new(code.to_string());
+    let mut errors = String::new();
+
+    let channel = args.params.get("channel").unwrap_or_else(|| &"nightly");
+    let mode = args.params.get("mode").unwrap_or_else(|| &"debug");
+    let edition = args.params.get("edition").unwrap_or_else(|| &"2018");
+
+    let mut request = PlaygroundCode::new(code);
+
+    match Channel::from_str(channel) {
+        Ok(c) => request.channel = c,
+        Err(e) => errors += &format!("{}\n", e),
+    }
+
+    match Mode::from_str(mode) {
+        Ok(m) => request.mode = m,
+        Err(e) => errors += &format!("{}\n", e),
+    }
+
+    match Edition::from_str(edition) {
+        Ok(e) => request.edition = e,
+        Err(e) => errors += &format!("{}\n", e),
+    }
+
+    if !code.contains("fn main") {
+        request.crate_type = CrateType::Library;
+    }
 
     let resp = args
         .http
@@ -112,13 +174,16 @@ fn run_code(args: &Args, code: &str) -> Result<String> {
         result.stderr
     };
 
-    Ok(if result.len() > 1994 {
+    Ok(if result.len() + errors.len() > 1994 {
         format!(
-            "Output too large. Playground link: {}",
+            "{}Output too large. Playground link: {}",
+            errors,
             get_playground_link(args, code, &request)?
         )
+    } else if result.len() == 0 {
+        format!("{}compilation succeded.", errors)
     } else {
-        format!("```{}```", result)
+        format!("{}```{}```", errors, result)
     })
 }
 
@@ -134,11 +199,11 @@ fn get_playground_link(args: &Args, code: &str, request: &PlaygroundCode) -> Res
         .send()?;
 
     let resp: HashMap<String, String> = resp.json()?;
-    debug!("gist response: {:?}", resp);
+    info!("gist response: {:?}", resp);
 
     resp.get("id")
         .map(|id| request.url_from_gist(id))
-        .ok_or("no gist found".into())
+        .ok_or_else(|| "no gist found".into())
 }
 
 pub fn run(args: Args) -> Result<()> {
@@ -152,7 +217,23 @@ pub fn run(args: Args) -> Result<()> {
     Ok(())
 }
 
-pub fn help(args: Args) -> Result<()> {
+pub fn help(args: Args, name: &str) -> Result<()> {
+    let message = format!(
+        "Compile and run rust code. All code is executed on https://play.rust-lang.org.
+```?{} mode={{}} channel={{}} edition={{}} ``\u{200B}`code``\u{200B}` ```
+Optional arguments:
+    \tmode: debug, release (default: debug)
+    \tchannel: stable, beta, nightly (default: nightly)
+    \tedition: 2015, 2018 (default: 2018)
+    ",
+        name
+    );
+
+    api::send_reply(&args, &message)?;
+    Ok(())
+}
+
+pub fn err(args: Args) -> Result<()> {
     let message = "Missing code block. Please use the following markdown:
 \\`\\`\\`rust
     code here
@@ -183,7 +264,7 @@ pub fn eval(args: Args) -> Result<()> {
     Ok(())
 }
 
-pub fn eval_help(args: Args) -> Result<()> {
+pub fn eval_err(args: Args) -> Result<()> {
     let message = "Missing code block. Please use the following markdown:
     \\`code here\\`
     or