doumanash / arg.rs Goto Github PK

#[derive(Args, Debug)]
struct Arguments {
  _argv0: String,

  #[arg(short = "c")]
  c: Option<String>,

  #[arg(short = "f")]
  f: bool,

  #[arg(short = "n", default_value: String = "-10")]
  n: String,

  #[arg(default_value = vec!["-"])]
  paths: Vec<String>,
}

fn main() {
  let (args, argv) = match get_args::<Arguments>() {
    Ok((args, argv)) => (args, argv),
    Err(err) => {
      eprintln!("{}", err);
      exit(EX_USAGE);
    },
  };

  let head = match Path::new(&argv[0]).file_name() {
    Some(val) => val.eq(OsStr::new("head")),
    None => false,
  };

  if head && (args.c.is_some() || args.f) {
    eprintln!("Usage: {} [options...] [file]", argv[0]);
    exit(EX_USAGE);
  }

  let count: isize;
  
  let opt = match args.c.is_some() {
    true => args.c.unwrap(),
    false => args.n,
  };

  match signs(&argv, opt) {
    Ok(RealSignedInt::Unsigned(val)) => {
      let out = val as isize;
      count = -out;
    },
    Ok(RealSignedInt::Signed(val)) => count = val,
    Err(err) => {
      eprintln!("{}", err);
      exit(EX_USAGE);
    },
  };
}

pub fn get_args<T: arg::Args>() -> Result<(T, Vec<String>), String> {
  let argv = args().collect::<Vec<String>>();

  match T::from_args(argv
    .iter()
    .map(String::as_str)
    .collect::<Vec<&str>>()
  ) {
    Ok(args) => Ok((args, argv)),
    Err(ParseKind::Top(kind)) => {
      Err(format!("{}: {}", argv[0], kind))
    },
    Err(ParseKind::Sub(command, kind)) => {
      Err(format!("Usage: {} {} [options...]", argv[0], command))
    }
  }
}

let mut args = std::env::args();
let _program_name = args.next().unwrap();
let args = ProgramArgs::from_args(args);
//let args = ProgramArgs::from_args(args.map(|arg| arg.as_str()));

#[derive(Args, Debug)]
struct Arguments {
  argv0: String,

  #[arg(subcommand)]
  get: Vec<String>,
}

Arguments.argv0 == "argv0";
Arguments.get == [ "string1", "string2", "string3" ]