chore: refactor, cli and rhai-common shared crate

Author: tamasfe

crates/lsp/bin/rhai/main.rs

@@ -0,0 +1,30 @@
+[package]
+name = "rhai-cli"
+version = "0.1.0"
+edition = "2021"
+publish = false
+
+[dependencies]
+rhai-common = { version = "0.1.0", path = "../rhai-common" }
+rhai-lsp = { version = "0.1.0", path = "../rhai-lsp" }
+
+clap = { version = "3.2.16", features = ["derive", "cargo"] }
+rhai = "1.8.0"
+anyhow = "1.0.59"
+async-ctrlc = { version = "1.2.0", features = ["stream"] }
+tracing = "0.1.36"
+
+[target.'cfg(not(target_arch = "wasm32"))'.dependencies]
+atty = "0.2.14"
+tokio = { version = "1.19.2", features = [
+    "sync",
+    "fs",
+    "time",
+    "io-std",
+    "rt-multi-thread",
+    "parking_lot",
+] }
+lsp-async-stub = { version = "0.6.0", features = ["tokio-tcp", "tokio-stdio"] }
+
+[target.'cfg(target_arch = "wasm32")'.dependencies]
+tokio = { version = "1.19.2", features = ["sync", "parking_lot", "io-util"] }

crates/rhai-cli/Cargo.toml

@@ -0,0 +1,49 @@
+use clap::{crate_version, ArgEnum, Parser, Subcommand};
+
+#[derive(Clone, Parser)]
+#[clap(name = "rhai")]
+#[clap(bin_name = "rhai")]
+#[clap(version = crate_version!())]
+pub struct RhaiArgs {
+    #[clap(long, arg_enum, global = true, default_value = "auto")]
+    pub colors: Colors,
+    /// Enable a verbose logging format.
+    #[clap(long, global = true)]
+    pub verbose: bool,
+    /// Enable logging spans.
+    #[clap(long, global = true)]
+    pub log_spans: bool,
+    #[clap(subcommand)]
+    pub cmd: RootCommand,
+}
+
+#[derive(Clone, Subcommand)]
+pub enum RootCommand {
+    /// Language server operations.
+    Lsp {
+        #[clap(subcommand)]
+        cmd: LspCommand,
+    },
+}
+
+#[derive(Clone, Subcommand)]
+pub enum LspCommand {
+    /// Run the language server and listen on a TCP address.
+    Tcp {
+        /// The address to listen on.
+        #[clap(long, default_value = "0.0.0.0:9181")]
+        address: String,
+    },
+    /// Run the language server over the standard input and output.
+    Stdio {},
+}
+
+#[derive(Clone, Copy, ArgEnum)]
+pub enum Colors {
+    /// Determine whether to colorize output automatically.
+    Auto,
+    /// Always colorize output.
+    Always,
+    /// Never colorize output.
+    Never,
+}

crates/rhai-cli/src/args.rs

@@ -0,0 +1,37 @@
+use clap::Parser;
+use rhai_cli::{
+    args::{Colors, RhaiArgs},
+    Rhai,
+};
+use rhai_common::{environment::native::NativeEnvironment, log::setup_stderr_logging};
+use std::process::exit;
+use tracing::Instrument;
+
+#[tokio::main]
+async fn main() {
+    let cli = RhaiArgs::parse();
+    setup_stderr_logging(
+        NativeEnvironment,
+        cli.log_spans,
+        cli.verbose,
+        match cli.colors {
+            Colors::Auto => None,
+            Colors::Always => Some(true),
+            Colors::Never => Some(false),
+        },
+    );
+
+    match Rhai::new(NativeEnvironment)
+        .execute(cli)
+        .instrument(tracing::info_span!("rhai"))
+        .await
+    {
+        Ok(_) => {
+            exit(0);
+        }
+        Err(error) => {
+            tracing::error!(error = %format!("{error:#}"), "operation failed");
+            exit(1);
+        }
+    }
+}

crates/rhai-cli/src/bin/rhai.rs

@@ -0,0 +1,23 @@
+use rhai_common::environment::{native::NativeEnvironment, Environment};
+
+use crate::{args::LspCommand, Rhai};
+
+impl<E: Environment> Rhai<E> {
+    pub async fn execute_lsp(&self, cmd: LspCommand) -> Result<(), anyhow::Error> {
+        let server = rhai_lsp::create_server();
+        let world = rhai_lsp::create_world(NativeEnvironment);
+
+        match cmd {
+            LspCommand::Tcp { address } => {
+                server
+                    .listen_tcp(world, &address, async_ctrlc::CtrlC::new().unwrap())
+                    .await
+            }
+            LspCommand::Stdio {} => {
+                server
+                    .listen_stdio(world, async_ctrlc::CtrlC::new().unwrap())
+                    .await
+            }
+        }
+    }
+}

crates/rhai-cli/src/execute/lsp.rs

@@ -0,0 +1,15 @@
+use crate::{
+    args::{RhaiArgs, RootCommand},
+    Rhai,
+};
+use rhai_common::environment::Environment;
+
+mod lsp;
+
+impl<E: Environment> Rhai<E> {
+    pub async fn execute(&mut self, args: RhaiArgs) -> Result<(), anyhow::Error> {
+        match args.cmd {
+            RootCommand::Lsp { cmd } => self.execute_lsp(cmd).await,
+        }
+    }
+}

crates/rhai-cli/src/execute/mod.rs

@@ -0,0 +1,15 @@
+pub mod args;
+mod execute;
+
+use rhai_common::environment::Environment;
+
+pub struct Rhai<E: Environment> {
+    #[allow(dead_code)]
+    env: E,
+}
+
+impl<E: Environment> Rhai<E> {
+    pub fn new(env: E) -> Self {
+        Self { env }
+    }
+}

crates/rhai-cli/src/lib.rs

@@ -0,0 +1,31 @@
+[package]
+name = "rhai-common"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+anyhow = "1.0.59"
+async-trait = "0.1.57"
+futures = "0.3.21"
+globset = "0.4.9"
+percent-encoding = "2.1.0"
+serde = { version = "1.0.142", features = ["derive"] }
+serde_json = "1.0.83"
+tracing = "0.1.36"
+tracing-subscriber = { version = "0.3.15", features = ["env-filter"] }
+url = "2.2.2"
+
+[target.'cfg(not(target_arch = "wasm32"))'.dependencies]
+tokio = { version = "1.19.2", features = [
+    "rt",
+    "rt-multi-thread",
+    "sync",
+    "parking_lot",
+    "macros",
+    "fs",
+    "time",
+] }
+glob = "0.3.0"
+atty = "0.2.14"

crates/rhai-common/Cargo.toml

@@ -1,27 +1,23 @@
-use std::path::{Path, PathBuf};
-
-use figment::{providers::Serialized, Figment};
-use serde::{Deserialize, Serialize};
-use serde_json::Value;
-
 use crate::{
     environment::Environment,
-    utils::{GlobRule, Normalize},
+    util::{GlobRule, Normalize},
 };
+use serde::{Deserialize, Serialize};
+use std::path::Path;
 
 #[derive(Debug, Default, Clone, Serialize, Deserialize)]
-pub struct RhaiConfig {
-    pub source: RhaiSourceConfig,
+pub struct Config {
+    pub source: SourceConfig,
 }
 
-impl RhaiConfig {
+impl Config {
     pub fn prepare(&mut self, e: &impl Environment, base: &Path) -> anyhow::Result<()> {
         self.source.prepare(e, base)
     }
 }
 
 #[derive(Debug, Default, Clone, Serialize, Deserialize)]
-pub struct RhaiSourceConfig {
+pub struct SourceConfig {
     /// A list of UNIX-style glob patterns
     /// for Rhai files that should be included.
     pub include: Option<Vec<String>>,
@@ -33,7 +29,7 @@ pub struct RhaiSourceConfig {
     pub file_rule: Option<GlobRule>,
 }
 
-impl RhaiSourceConfig {
+impl SourceConfig {
     pub fn prepare(&mut self, e: &impl Environment, base: &Path) -> anyhow::Result<()> {
         self.make_absolute(e, base);
 
@@ -76,54 +72,3 @@ impl RhaiSourceConfig {
         }
     }
 }
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct InitConfig {
-    pub cache_path: Option<PathBuf>,
-    #[serde(default = "default_configuration_section")]
-    pub configuration_section: String,
-}
-
-impl Default for InitConfig {
-    fn default() -> Self {
-        Self {
-            cache_path: Default::default(),
-            configuration_section: default_configuration_section(),
-        }
-    }
-}
-
-fn default_configuration_section() -> String {
-    String::from("rhai")
-}
-
-#[derive(Debug, Clone, Default, Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct LspConfig {
-    pub syntax: SyntaxConfig,
-}
-
-impl LspConfig {
-    pub fn update_from_json(&mut self, json: &Value) -> Result<(), anyhow::Error> {
-        *self = Figment::new()
-            .merge(Serialized::defaults(&self))
-            .merge(Serialized::defaults(json))
-            .extract()?;
-        Ok(())
-    }
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct SyntaxConfig {
-    pub semantic_tokens: bool,
-}
-
-impl Default for SyntaxConfig {
-    fn default() -> Self {
-        Self {
-            semantic_tokens: true,
-        }
-    }
-}