scopt

A monadic commandline options parser.

import scopt.OParser
val builder = OParser.builder[Config]
val parser1 = {
 import builder._
 OParser.sequence(
   programName("scopt"),
   head("scopt", "4.x"),
   opt[Int]('f', "foo")
     .action((x, c) => c.copy(foo = x))
     .text("foo is an integer property"),
   opt[File]('o', "out")
     .required()
     .valueName("<file>")
     .action((x, c) => c.copy(out = x))
     .text("out is a required file property"),
   opt[(String, Int)]("max")
     .action({ case ((k, v), c) => c.copy(libName = k, maxCount = v) })
     .validate(x =>
       if (x._2 > 0) success
       else failure("Value <max> must be >0"))
     .keyValueName("<libname>", "<max>")
     .text("maximum count for <libname>"),
   opt[Seq[File]]('j', "jars")
     .valueName("<jar1>,<jar2>...")
     .action((x, c) => c.copy(jars = x))
     .text("jars to include"),
   opt[Map[String, String]]("kwargs")
     .valueName("k1=v1,k2=v2...")
     .action((x, c) => c.copy(kwargs = x))
     .text("other arguments"),
   opt[Unit]("verbose")
     .action((_, c) => c.copy(verbose = true))
     .text("verbose is a flag"),
   opt[Unit]("debug")
     .hidden()
     .action((_, c) => c.copy(debug = true))
     .text("this option is hidden in the usage text"),
   help("help").text("prints this usage text"),
   arg[File]("<file>...")
     .unbounded()
     .optional()
     .action((x, c) => c.copy(files = c.files :+ x))
     .text("optional unbounded args"),
   note("some notes." + sys.props("line.separator")),
   cmd("update")
     .action((_, c) => c.copy(mode = "update"))
     .text("update is a command.")
     .children(
       opt[Unit]("not-keepalive")
         .abbr("nk")
         .action((_, c) => c.copy(keepalive = false))
         .text("disable keepalive"),
       opt[Boolean]("xyz")
         .action((x, c) => c.copy(xyz = x))
         .text("xyz is a boolean property"),
       opt[Unit]("debug-update")
         .hidden()
         .action((_, c) => c.copy(debug = true))
         .text("this option is hidden in the usage text"),
       checkConfig(
         c =>
           if (c.keepalive && c.xyz) failure("xyz cannot keep alive")
           else success)
     )
 )
}

// OParser.parse returns Option[Config]
OParser.parse(parser1, args, Config()) match {
 case Some(config) =>
   // do something
 case _ =>
   // arguments are bad, error message will have been displayed
}

// alternatively, use OParser.runParser returns (Option[Config], List[OEffect])
OParser.runParser(parser1, args, Config()) match {
 case (result, effects) =>
   OParser.runEffects(effects, new DefaultOEffectSetup {
     // override def displayToOut(msg: String): Unit = Console.out.println(msg)
     // override def displayToErr(msg: String): Unit = Console.err.println(msg)
     // override def reportError(msg: String): Unit = displayToErr("Error: " + msg)
     // override def reportWarning(msg: String): Unit = displayToErr("Warning: " + msg)

     // ignore terminate
     override def terminate(exitState: Either[String, Unit]): Unit = ()
   })

   result match {
     Some(config) =>
       // do something
     case _ =>
       // arguments are bad, error message will have been displayed
   }
}

scopt.immutable.OptionParser is instantiated within your object, set up by an (ordered) sequence of invocations of the various builder methods such as opt method or arg method.

val parser = new scopt.OptionParser[Config]("scopt") {
 head("scopt", "4.x")

 opt[Int]('f', "foo").action( (x, c) =>
   c.copy(foo = x) ).text("foo is an integer property")

 opt[File]('o', "out").required().valueName("<file>").
   action( (x, c) => c.copy(out = x) ).
   text("out is a required file property")

 opt[(String, Int)]("max").action({
     case ((k, v), c) => c.copy(libName = k, maxCount = v) }).
   validate( x =>
     if (x._2 > 0) success
     else failure("Value <max> must be >0") ).
   keyValueName("<libname>", "<max>").
   text("maximum count for <libname>")

 opt[Seq[File]]('j', "jars").valueName("<jar1>,<jar2>...").action( (x,c) =>
   c.copy(jars = x) ).text("jars to include")

 opt[Map[String,String]]("kwargs").valueName("k1=v1,k2=v2...").action( (x, c) =>
   c.copy(kwargs = x) ).text("other arguments")

 opt[Unit]("verbose").action( (_, c) =>
   c.copy(verbose = true) ).text("verbose is a flag")

 opt[Unit]("debug").hidden().action( (_, c) =>
   c.copy(debug = true) ).text("this option is hidden in the usage text")

 help("help").text("prints this usage text")

 arg[File]("<file>...").unbounded().optional().action( (x, c) =>
   c.copy(files = c.files :+ x) ).text("optional unbounded args")

 note("some notes.".newline)

 cmd("update").action( (_, c) => c.copy(mode = "update") ).
   text("update is a command.").
   children(
     opt[Unit]("not-keepalive").abbr("nk").action( (_, c) =>
       c.copy(keepalive = false) ).text("disable keepalive"),
     opt[Boolean]("xyz").action( (x, c) =>
       c.copy(xyz = x) ).text("xyz is a boolean property"),
     opt[Unit]("debug-update").hidden().action( (_, c) =>
       c.copy(debug = true) ).text("this option is hidden in the usage text"),
     checkConfig( c =>
       if (c.keepalive && c.xyz) failure("xyz cannot keep alive")
       else success )
   )
}

// parser.parse returns Option[C]
parser.parse(args, Config()) match {
 case Some(config) =>
   // do stuff

 case None =>
   // arguments are bad, error message will have been displayed
}