Make sure that list of plugins is sorted and unique

forc/src/cli/commands/plugins.rs

@@ -18,15 +18,32 @@ pub struct Command {
     describe: bool,
 }
 
+fn get_file_name(path: &Path) -> String {
+    if let Some(Some(path_str)) = path.file_name().map(|path_str| path_str.to_str()) {
+        path_str.to_owned()
+    } else {
+        path.display().to_string()
+    }
+}
+
 pub(crate) fn exec(command: PluginsCommand) -> ForcResult<()> {
     let PluginsCommand {
         print_full_path,
         describe,
     } = command;
 
+    let mut plugins = crate::cli::plugin::find_all()
+        .map(|path| {
+            print_plugin(path.clone(), print_full_path, describe)
+                .map(|info| (get_file_name(&path), info))
+        })
+        .collect::<Result<Vec<(String, String)>, _>>()?;
+    plugins.sort_by(|a, b| a.0.cmp(&b.0));
+    plugins.dedup_by(|a, b| a.0 == b.0);
+
     info!("Installed Plugins:");
-    for path in crate::cli::plugin::find_all() {
-        info!("{}", print_plugin(path, print_full_path, describe)?);
+    for plugin in plugins {
+        info!("{}", plugin.1);
     }
     Ok(())
 }
@@ -72,11 +89,7 @@ fn format_print_description(
     let display = if print_full_path {
         path.display().to_string()
     } else {
-        path.file_name()
-            .expect("Failed to read file name")
-            .to_str()
-            .expect("Failed to print file name")
-            .to_string()
+        get_file_name(&path)
     };
 
     let description = parse_description_for_plugin(&path);

forc/src/cli/mod.rs

@@ -106,7 +106,7 @@ pub async fn run_cli() -> ForcResult<()> {
         Forc::ContractId(command) => contract_id::exec(command),
         Forc::PredicateRoot(command) => predicate_root::exec(command),
         Forc::Plugin(args) => {
-            let output = plugin::execute_external_subcommand(args)?;
+            let output = plugin::execute_external_subcommand(args, opt.verbose > 0)?;
             let code = output
                 .status
                 .code()

forc/src/cli/plugin.rs

@@ -14,14 +14,35 @@ use std::{
 ///
 /// E.g. given `foo bar baz` where `foo` is an unrecognized subcommand to `forc`, tries to execute
 /// `forc-foo bar baz`.
-pub(crate) fn execute_external_subcommand(args: Vec<String>) -> Result<process::Output> {
+pub(crate) fn execute_external_subcommand(
+    args: Vec<String>,
+    is_verbose: bool,
+) -> Result<process::Output> {
     let cmd = args.get(0).expect("`args` must not be empty");
     let args = &args[1..];
     let path = find_external_subcommand(cmd);
     let command = match path {
         Some(command) => command,
         None => bail!("no such subcommand: `{}`", cmd),
     };
+
+    if let Ok(forc_path) = std::env::current_exe() {
+        if is_verbose && command.parent() != forc_path.parent() {
+            let bold_yellow_code = "\x1b[1;33m";
+            let bold_white_code = "\x1b[1;37m";
+            let reset_code = "\x1b[0m";
+            eprintln!(
+                "{}WARNING:{} The {} ({}) plugin is in a different directory than forc ({}){}\n",
+                bold_yellow_code,
+                bold_white_code,
+                cmd,
+                command.display(),
+                forc_path.display(),
+                reset_code,
+            );
+        }
+    }
+
     let output = process::Command::new(command)
         .stdin(process::Stdio::inherit())
         .stdout(process::Stdio::inherit())