fix(global): fix global option can't be downcast

.changeset/curly-crews-pull.md

@@ -0,0 +1,5 @@
+---
+'archons': patch
+---
+
+Wrap `parse_arguments` to inner function

.changeset/perfect-fishes-trade.md

@@ -0,0 +1,5 @@
+---
+'archons': patch
+---
+
+Fix global option can't be downcast

__test__/global.spec.ts

@@ -0,0 +1,32 @@
+import test from 'ava'
+
+import { Context, defineCommand, run } from '../index'
+
+test('global option', (t) => {
+  const dev = defineCommand({
+    meta: {
+      name: 'dev',
+    },
+    options: {},
+    callback: (ctx: Context) => {
+      t.is(ctx.args.config, 'config.json')
+    },
+  })
+  const main = defineCommand({
+    meta: {
+      name: 'test',
+    },
+    options: {
+      config: {
+        type: 'option',
+        global: true,
+      },
+    },
+    subcommands: {
+      dev,
+    },
+  })
+  t.notThrows(() => {
+    run(main, ['node', 'test.js', 'dev', '--config', 'config.json'])
+  })
+})

examples/global.cts

@@ -0,0 +1,30 @@
+import { Context, defineCommand, run } from '..'
+
+const dev = defineCommand({
+  meta: {
+    name: 'dev',
+  },
+  options: {},
+  callback: (ctx: Context) => {
+    console.log(ctx.args.config)
+  },
+})
+const main = defineCommand({
+  meta: {
+    name: 'test',
+  },
+  options: {
+    config: {
+      type: 'option',
+      global: true,
+    },
+  },
+  subcommands: {
+    dev,
+  },
+  callback: (ctx: Context) => {
+    console.log(ctx.args.config)
+  },
+})
+
+run(main)

src/command.rs

@@ -1,5 +1,3 @@
-use std::collections::HashMap;
-
 use napi::{Env, Result};
 use napi_derive::napi;
 
@@ -18,15 +16,5 @@ pub fn run(env: Env, cmd: Command, args: Option<Vec<String>>) -> Result<()> {
   let clap = resolve_command(clap::Command::default(), Default::default(), &cmd);
   let matches = clap.clone().get_matches_from(&raw_args);
 
-  parse_arguments(
-    env,
-    env.create_object()?,
-    &clap,
-    cmd,
-    &matches,
-    raw_args,
-    HashMap::new(),
-  )?;
-
-  Ok(())
+  parse_arguments(env, &clap, cmd, &matches, raw_args)
 }

src/resolver.rs

@@ -63,8 +63,7 @@ pub(crate) fn resolve_action(action: &Option<String>, type_: &Option<String>) ->
     Some("store") => clap::ArgAction::SetTrue,
     Some("store_false") => clap::ArgAction::SetFalse,
     None => match type_ {
-      "option" => clap::ArgAction::SetTrue,
-      "positional" => clap::ArgAction::Set,
+      "option" | "positional" => clap::ArgAction::Set,
       _ => panic!("Unsupported type: {:?}", type_),
     },
     _ => panic!("Unsupported action: {:?}", action),

src/utils.rs

@@ -20,13 +20,13 @@ pub(crate) fn leak_borrowed_str(s: &String) -> &'static str {
 
 pub(crate) fn merge_args_matches(
   parsed_args: &mut JsObject,
-  clap: &clap::Command,
+  args: &[&clap::Arg],
   options: &HashMap<String, &'static str>,
   matches: &clap::ArgMatches,
 ) -> Result<()> {
   for id in matches.ids() {
-    let action = clap
-      .get_arguments()
+    let action = args
+      .iter()
       .find(|&arg| arg.get_id() == id)
       .expect(&format!(
         "{}\n{}",
@@ -83,14 +83,15 @@ pub(crate) fn merge_args_matches(
   Ok(())
 }
 
-pub(crate) fn parse_arguments(
+pub(crate) fn parse_arguments_inner<'arg>(
   env: Env,
   mut parsed_args: JsObject,
-  clap: &clap::Command,
+  clap: &'arg clap::Command,
   cmd: Command,
   matches: &clap::ArgMatches,
   raw_args: Vec<String>,
   mut global_options: HashMap<String, &'static str>,
+  mut global_args: Vec<&'arg clap::Arg>,
 ) -> napi::Result<()> {
   let mut options: HashMap<String, &'static str> = HashMap::new();
   options.extend(global_options.clone());
@@ -102,7 +103,15 @@ pub(crate) fn parse_arguments(
     }
   }
 
-  merge_args_matches(&mut parsed_args, clap, &options, &matches)?;
+  let mut args = clap.get_arguments().collect::<Vec<&clap::Arg>>();
+  args.extend(global_args.clone());
+  let global_args_this = clap
+    .get_arguments()
+    .filter(|arg| arg.is_global_set())
+    .collect::<Vec<&clap::Arg>>();
+  global_args.extend(global_args_this);
+
+  merge_args_matches(&mut parsed_args, &args, &options, &matches)?;
 
   if let Some((sub_command_name, sub_matches)) = matches.subcommand() {
     let mut sub_commands = cmd.subcommands.unwrap_or_default();
@@ -113,14 +122,15 @@ pub(crate) fn parse_arguments(
       .find(|&sub_command| sub_command.get_name() == sub_command_name)
       .unwrap();
 
-    parse_arguments(
+    parse_arguments_inner(
       env,
       parsed_args,
       sub_command,
       sub_command_def,
       sub_matches,
       raw_args,
       global_options,
+      global_args,
     )?;
   } else {
     let context = Context {
@@ -138,3 +148,24 @@ pub(crate) fn parse_arguments(
   };
   Ok(())
 }
+
+pub(crate) fn parse_arguments<'arg>(
+  env: Env,
+  clap: &'arg clap::Command,
+  cmd: Command,
+  matches: &clap::ArgMatches,
+  raw_args: Vec<String>,
+) -> napi::Result<()> {
+  let parsed_args = env.create_object()?;
+
+  parse_arguments_inner(
+    env,
+    parsed_args,
+    clap,
+    cmd,
+    matches,
+    raw_args,
+    HashMap::new(),
+    Vec::new(),
+  )
+}