Merge pull request #99 from rhaiscript:cli/feat-fmt

Formattin and config in CLI

Author: tamasfe

crates/rhai-cli/Cargo.toml

@@ -13,7 +13,17 @@ rhai = "1.8.0"
 anyhow = "1.0.59"
 async-ctrlc = { version = "1.2.0", features = ["stream"] }
 tracing = "0.1.36"
-rhai-fmt = { version = "0.1.0", path = "../rhai-fmt" }
+rhai-fmt = { version = "0.1.0", path = "../rhai-fmt", features = ["schema"] }
+schemars = "0.8.10"
+toml = "0.5.9"
+figment = "0.10.6"
+serde_json = "1.0.85"
+codespan-reporting = "0.11.1"
+rhai-rowan = { version = "0.1.0", path = "../rhai-rowan" }
+itertools = "0.10.3"
+glob = "0.3.0"
+rhai-hir = { version = "0.1.0", path = "../rhai-hir" }
+url = "2.2.2"
 
 [target.'cfg(not(target_arch = "wasm32"))'.dependencies]
 atty = "0.2.14"

crates/rhai-cli/src/args.rs

@@ -1,3 +1,5 @@
+use std::path::PathBuf;
+
 use clap::{crate_version, ArgEnum, Parser, Subcommand};
 
 #[derive(Clone, Parser)]
@@ -13,6 +15,9 @@ pub struct RhaiArgs {
     /// Enable logging spans.
     #[clap(long, global = true)]
     pub log_spans: bool,
+    /// Path to `Rhai.toml` configuration file.
+    #[clap(long, global = true)]
+    pub config: Option<PathBuf>,
     #[clap(subcommand)]
     pub cmd: RootCommand,
 }
@@ -24,6 +29,15 @@ pub enum RootCommand {
         #[clap(subcommand)]
         cmd: LspCommand,
     },
+    /// Configuration file operations
+    #[clap(visible_aliases = &["cfg"])]
+    Config {
+        #[clap(subcommand)]
+        cmd: ConfigCommand,
+    },
+    /// Format Rhai source code.
+    #[clap(visible_aliases = &["format"])]
+    Fmt(FmtCommand),
 }
 
 #[derive(Clone, Subcommand)]
@@ -35,7 +49,37 @@ pub enum LspCommand {
         address: String,
     },
     /// Run the language server over the standard input and output.
-    Stdio {},
+    Stdio,
+}
+
+#[derive(Clone, Subcommand)]
+pub enum ConfigCommand {
+    /// Print the configuration JSON schema.
+    Schema,
+    /// Create a new configuration file with default values.
+    Init {
+        /// Output file path.
+        #[clap(short = 'o', long, default_value = "Rhai.toml")]
+        output: String,
+    },
+}
+
+#[derive(Clone, Parser)]
+pub struct FmtCommand {
+    /// Proceed with formatting even if the files contain
+    /// syntax errors.
+    #[clap(short, long)]
+    pub force: bool,
+
+    /// Dry-run and report any files that are not correctly formatted.
+    #[clap(long)]
+    pub check: bool,
+
+    /// Optional pattern to search for files.
+    ///
+    /// If not provided, it will be determined by
+    /// the configuration.
+    pub files: Option<String>,
 }
 
 #[derive(Clone, Copy, ArgEnum)]

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

@@ -0,0 +1,44 @@
+use std::path::PathBuf;
+
+use anyhow::Context;
+use rhai_common::{config::Config, environment::Environment};
+use tokio::io::AsyncWriteExt;
+
+use crate::{args::ConfigCommand, Rhai};
+
+impl<E: Environment> Rhai<E> {
+    pub async fn execute_config(&self, cmd: ConfigCommand) -> Result<(), anyhow::Error> {
+        let mut stdout = self.env.stdout();
+
+        match cmd {
+            ConfigCommand::Schema => {
+                stdout
+                    .write_all(&serde_json::to_vec(&schemars::schema_for!(Config))?)
+                    .await?;
+            }
+            ConfigCommand::Init { output } => {
+                let mut p = PathBuf::from(output);
+
+                if !self.env.is_absolute(&p) {
+                    p = self.env.cwd().context("invalid working directory")?.join(p);
+                }
+
+                if self.env.read_file(&p).await.is_ok() {
+                    tracing::info!("already initialized");
+                    return Ok(());
+                }
+
+                self.env
+                    .write_file(
+                        &p,
+                        toml::to_string_pretty(&Config::default())
+                            .unwrap()
+                            .as_bytes(),
+                    )
+                    .await?;
+            }
+        }
+
+        Ok(())
+    }
+}

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

@@ -0,0 +1,91 @@
+use std::path::{Path, PathBuf};
+
+use anyhow::{anyhow, Context};
+use codespan_reporting::files::SimpleFile;
+use rhai_common::{environment::Environment, util::Normalize};
+use rhai_fmt::format_syntax;
+
+use crate::{args::FmtCommand, Rhai};
+
+impl<E: Environment> Rhai<E> {
+    pub async fn execute_fmt(&mut self, cmd: FmtCommand) -> Result<(), anyhow::Error> {
+        let cwd = self
+            .env
+            .cwd()
+            .context("invalid working directory")?
+            .normalize();
+
+        let hir = self.load_hir(&cwd).await?;
+
+        if let Some(mut files) = cmd.files {
+            if self.env.is_dir(Path::new(&files)) {
+                files = PathBuf::from(files)
+                    .join("**/*.rhai")
+                    .normalize()
+                    .to_string_lossy()
+                    .into();
+            }
+
+            self.config.source.include = Some(vec![files]);
+            self.config.source.exclude = None;
+        }
+
+        self.config.prepare(
+            &self.env,
+            &self.env.cwd().context("invalid working directory")?,
+        )?;
+
+        let files = self.collect_files(&cwd, &self.config, true).await?;
+
+        let mut result = Ok(());
+
+        let mut format_opts = rhai_fmt::Options::default();
+        format_opts.update(self.config.fmt.options.clone());
+
+        for path in files {
+            let f = self.env.read_file(&path).await?;
+            let source = String::from_utf8_lossy(&f).into_owned();
+
+            let parser = rhai_rowan::Parser::new(&source).with_operators(hir.parser_operators());
+
+            let p = if rhai_rowan::util::is_rhai_def(&source) {
+                parser.parse_def()
+            } else {
+                parser.parse_script()
+            };
+
+            if !p.errors.is_empty() {
+                self.print_parse_errors(
+                    &SimpleFile::new(&*path.to_string_lossy(), source.as_str()),
+                    &p.errors,
+                )
+                .await?;
+
+                if !cmd.force {
+                    if cmd.check {
+                        result = Err(anyhow!("some files had syntax errors"));
+                    } else {
+                        result = Err(anyhow!(
+                            "some files were not formatted due to syntax errors"
+                        ));
+                    }
+
+                    continue;
+                }
+            }
+
+            let formatted = format_syntax(p.into_syntax(), format_opts.clone());
+
+            if source != formatted {
+                if cmd.check {
+                    tracing::error!(?path, "the file is not properly formatted");
+                    result = Err(anyhow!("some files were not properly formatted"));
+                } else {
+                    self.env.write_file(&path, formatted.as_bytes()).await?;
+                }
+            }
+        }
+
+        result
+    }
+}

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

@@ -1,15 +1,29 @@
 use crate::{
-    args::{RhaiArgs, RootCommand},
+    args::{Colors, RhaiArgs, RootCommand},
     Rhai,
 };
 use rhai_common::environment::Environment;
 
+mod config;
+mod fmt;
 mod lsp;
 
 impl<E: Environment> Rhai<E> {
     pub async fn execute(&mut self, args: RhaiArgs) -> Result<(), anyhow::Error> {
+        if let RootCommand::Fmt(_) = &args.cmd {
+            self.load_config(&args).await?
+        }
+
+        self.colors = match args.colors {
+            Colors::Auto => self.env.atty_stderr(),
+            Colors::Always => true,
+            Colors::Never => false,
+        };
+
         match args.cmd {
             RootCommand::Lsp { cmd } => self.execute_lsp(cmd).await,
+            RootCommand::Config { cmd } => self.execute_config(cmd).await,
+            RootCommand::Fmt(cmd) => self.execute_fmt(cmd).await,
         }
     }
 }