don't pass argv around, just generate it when needed

Author: mikrostew

crates/volta-core/src/event.rs

@@ -100,7 +100,11 @@ impl EventLog {
         EventLog { events: Vec::new() }
     }
 
-    pub fn add_event_start(&mut self, activity_kind: ActivityKind, argv: String) {
+    pub fn add_event_start(&mut self, activity_kind: ActivityKind) {
+        let argv = env::args_os()
+            .map(|arg| arg.to_string_lossy().to_string())
+            .collect::<Vec<String>>()
+            .join(" ");
         self.add_event(EventKind::Start { argv }, activity_kind)
     }
     pub fn add_event_end(&mut self, activity_kind: ActivityKind, exit_code: ExitCode) {
@@ -148,21 +152,28 @@ pub mod tests {
     use super::{EventKind, EventLog};
     use crate::error::{ErrorKind, ExitCode};
     use crate::session::ActivityKind;
+    use regex::Regex;
 
     #[test]
     fn test_adding_events() {
         let mut event_log = EventLog::init();
         assert_eq!(event_log.events.len(), 0);
 
-        event_log.add_event_start(ActivityKind::Current, String::from("foo"));
+        event_log.add_event_start(ActivityKind::Current);
         assert_eq!(event_log.events.len(), 1);
         assert_eq!(event_log.events[0].name, "current");
-        assert_eq!(
-            event_log.events[0].event,
-            EventKind::Start {
-                argv: String::from("foo")
+        match event_log.events[0].event {
+            EventKind::Start { ref argv } => {
+                let re = Regex::new("volta_core").unwrap();
+                assert!(re.is_match(argv));
             }
-        );
+            _ => {
+                panic!(
+                    "Expected EventKind::Start {{ argv }}, Got: {:?}",
+                    event_log.events[0].event
+                );
+            }
+        }
 
         event_log.add_event_end(ActivityKind::Pin, ExitCode::NetworkError);
         assert_eq!(event_log.events.len(), 2);

crates/volta-core/src/run/node.rs

@@ -9,12 +9,7 @@ use crate::session::{ActivityKind, Session};
 
 /// Build a `ToolCommand` for Node
 pub(super) fn command(args: &[OsString], session: &mut Session) -> Fallible<Executor> {
-    let node_argv = args
-        .iter()
-        .map(|s| s.to_string_lossy().to_string())
-        .collect::<Vec<String>>()
-        .join(" ");
-    session.add_event_start(ActivityKind::Node, node_argv);
+    session.add_event_start(ActivityKind::Node);
     // Don't re-evaluate the platform if this is a recursive call
     let platform = match env::var_os(RECURSION_ENV_VAR) {
         Some(_) => None,

crates/volta-core/src/run/npm.rs

@@ -20,12 +20,7 @@ use crate::version::VersionSpec;
 /// If the command is _not_ a global install / uninstall or we don't have a default platform, then
 /// we will allow npm to execute the command as usual.
 pub(super) fn command(args: &[OsString], session: &mut Session) -> Fallible<Executor> {
-    let npm_argv = args
-        .iter()
-        .map(|s| s.to_string_lossy().to_string())
-        .collect::<Vec<String>>()
-        .join(" ");
-    session.add_event_start(ActivityKind::Npm, npm_argv);
+    session.add_event_start(ActivityKind::Npm);
     // Don't re-evaluate the context or global install interception if this is a recursive call
     let platform = match env::var_os(RECURSION_ENV_VAR) {
         Some(_) => None,

crates/volta-core/src/run/npx.rs

@@ -16,12 +16,7 @@ lazy_static! {
 
 /// Build a `ToolCommand` for npx
 pub(super) fn command(args: &[OsString], session: &mut Session) -> Fallible<Executor> {
-    let npx_argv = args
-        .iter()
-        .map(|s| s.to_string_lossy().to_string())
-        .collect::<Vec<String>>()
-        .join(" ");
-    session.add_event_start(ActivityKind::Npx, npx_argv);
+    session.add_event_start(ActivityKind::Npx);
     // Don't re-evaluate the context if this is a recursive call
     let platform = match env::var_os(RECURSION_ENV_VAR) {
         Some(_) => None,

crates/volta-core/src/run/yarn.rs

@@ -17,12 +17,7 @@ use crate::session::{ActivityKind, Session};
 /// If the command is _not_ a global add / remove or we don't have a default platform, then
 /// we will allow Yarn to execute the command as usual.
 pub(super) fn command(args: &[OsString], session: &mut Session) -> Fallible<Executor> {
-    let yarn_argv = args
-        .iter()
-        .map(|s| s.to_string_lossy().to_string())
-        .collect::<Vec<String>>()
-        .join(" ");
-    session.add_event_start(ActivityKind::Yarn, yarn_argv);
+    session.add_event_start(ActivityKind::Yarn);
     // Don't re-evaluate the context or global install interception if this is a recursive call
     let platform = match env::var_os(RECURSION_ENV_VAR) {
         Some(_) => None,

crates/volta-core/src/session.rs

@@ -131,8 +131,8 @@ impl Session {
         self.hooks.get(self.project()?)
     }
 
-    pub fn add_event_start(&mut self, activity_kind: ActivityKind, argv: String) {
-        self.event_log.add_event_start(activity_kind, argv)
+    pub fn add_event_start(&mut self, activity_kind: ActivityKind) {
+        self.event_log.add_event_start(activity_kind)
     }
     pub fn add_event_end(&mut self, activity_kind: ActivityKind, exit_code: ExitCode) {
         self.event_log.add_event_end(activity_kind, exit_code)

src/cli.rs

@@ -45,7 +45,7 @@ pub(crate) struct Volta {
 }
 
 impl Volta {
-    pub(crate) fn run(self, session: &mut Session, argv: String) -> Fallible<ExitCode> {
+    pub(crate) fn run(self, session: &mut Session) -> Fallible<ExitCode> {
         if self.version {
             // suffix indicator for dev build
             if cfg!(debug_assertions) {
@@ -55,9 +55,9 @@ impl Volta {
             }
             Ok(ExitCode::Success)
         } else if let Some(command) = self.command {
-            command.run(session, argv)
+            command.run(session)
         } else {
-            Volta::from_iter(["volta", "help"].iter()).run(session, argv)
+            Volta::from_iter(["volta", "help"].iter()).run(session)
         }
     }
 }
@@ -130,18 +130,18 @@ otherwise, they will be written to `stdout`.
 }
 
 impl Subcommand {
-    pub(crate) fn run(self, session: &mut Session, argv: String) -> Fallible<ExitCode> {
+    pub(crate) fn run(self, session: &mut Session) -> Fallible<ExitCode> {
         match self {
-            Subcommand::Fetch(fetch) => fetch.run(session, argv),
-            Subcommand::Install(install) => install.run(session, argv),
-            Subcommand::Uninstall(uninstall) => uninstall.run(session, argv),
-            Subcommand::Pin(pin) => pin.run(session, argv),
-            Subcommand::List(list) => list.run(session, argv),
-            Subcommand::Completions(completions) => completions.run(session, argv),
-            Subcommand::Which(which) => which.run(session, argv),
-            Subcommand::Use(r#use) => r#use.run(session, argv),
-            Subcommand::Setup(setup) => setup.run(session, argv),
-            Subcommand::Run(run) => run.run(session, argv),
+            Subcommand::Fetch(fetch) => fetch.run(session),
+            Subcommand::Install(install) => install.run(session),
+            Subcommand::Uninstall(uninstall) => uninstall.run(session),
+            Subcommand::Pin(pin) => pin.run(session),
+            Subcommand::List(list) => list.run(session),
+            Subcommand::Completions(completions) => completions.run(session),
+            Subcommand::Which(which) => which.run(session),
+            Subcommand::Use(r#use) => r#use.run(session),
+            Subcommand::Setup(setup) => setup.run(session),
+            Subcommand::Run(run) => run.run(session),
         }
     }
 }

src/command/completions.rs

@@ -32,8 +32,8 @@ pub(crate) struct Completions {
 }
 
 impl Command for Completions {
-    fn run(self, session: &mut Session, argv: String) -> Fallible<ExitCode> {
-        session.add_event_start(ActivityKind::Completions, argv);
+    fn run(self, session: &mut Session) -> Fallible<ExitCode> {
+        session.add_event_start(ActivityKind::Completions);
 
         let mut app = crate::cli::Volta::clap();
         match self.out_file {

src/command/fetch.rs

@@ -14,8 +14,8 @@ pub(crate) struct Fetch {
 }
 
 impl Command for Fetch {
-    fn run(self, session: &mut Session, argv: String) -> Fallible<ExitCode> {
-        session.add_event_start(ActivityKind::Fetch, argv);
+    fn run(self, session: &mut Session) -> Fallible<ExitCode> {
+        session.add_event_start(ActivityKind::Fetch);
 
         for tool in tool::Spec::from_strings(&self.tools, "fetch")? {
             tool.resolve(session)?.fetch(session)?;

src/command/install.rs

@@ -14,8 +14,8 @@ pub(crate) struct Install {
 }
 
 impl Command for Install {
-    fn run(self, session: &mut Session, argv: String) -> Fallible<ExitCode> {
-        session.add_event_start(ActivityKind::Install, argv);
+    fn run(self, session: &mut Session) -> Fallible<ExitCode> {
+        session.add_event_start(ActivityKind::Install);
 
         for tool in Spec::from_strings(&self.tools, "install")? {
             tool.resolve(session)?.install(session)?;