OParser

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("")
      .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  must be >0"))
      .keyValueName("", "")
      .text("maximum count for "),
    opt[Seq[File]]('j', "jars")
      .valueName(",...")
      .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]("...")
      .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
    }
}

Linear Supertypes

AnyRef, Any

Instance Constructors

new OParser(head: OptionDef[A, C], rest: List[OptionDef[_, C]])

Value Members

final def !=(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def ##(): Int

Definition Classes
AnyRef → Any
def ++(other: OParser[_, C]): OParser[A, C]
final def ==(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def abbr(x: String): OParser[A, C]

Adds short option -x.
def action(f: (A, C) ⇒ C): OParser[A, C]

Adds a callback function.
final def asInstanceOf[T0]: T0

Definition Classes
Any
def children(cs: OParser[_, C]*): OParser[A, C]

Adds a parser under this command.
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def equals(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
def flatMap(f: (Unit) ⇒ OParser[_, C]): OParser[A, C]
def foreach(f: (Unit) ⇒ Unit): Unit
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def hashCode(): Int

Definition Classes
AnyRef → Any
def hidden(): OParser[A, C]

Hides the option in any usage text.
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
def keyName(x: String): OParser[A, C]

Adds key name used in the usage text.
def keyValueName(k: String, v: String): OParser[A, C]

Adds key and value names used in the usage text.
def map(f: (Unit) ⇒ Unit): OParser[A, C]
def maxOccurs(n: Int): OParser[A, C]

Allows the argument to appear at most n times.
def minOccurs(n: Int): OParser[A, C]

Requires the option to appear at least n times.
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
def optional(): OParser[A, C]

Chanages the option to be optional.
def required(): OParser[A, C]

Requires the option to appear at least once.
def subHead[B](head: OptionDef[B, C]): OParser[B, C]

Attributes
protected
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def text(x: String): OParser[A, C]

Adds description in the usage text.
def toList: List[OptionDef[_, C]]
def toString(): String

Definition Classes
AnyRef → Any
def unbounded(): OParser[A, C]

Allows the argument to appear multiple times.
def validate(f: (A) ⇒ Either[String, Unit]): OParser[A, C]

Adds custom validation.
def valueName(x: String): OParser[A, C]

Adds value name used in the usage text.
final def wait(): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long, arg1: Int): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )

Related Docs: object OParser | package scopt

class OParser[A, C] extends AnyRef

Instance Constructors

new OParser(head: OptionDef[A, C], rest: List[OptionDef[_, C]])

Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

def ++(other: OParser[_, C]): OParser[A, C]

final def ==(arg0: Any): Boolean

def abbr(x: String): OParser[A, C]

def action(f: (A, C) ⇒ C): OParser[A, C]

final def asInstanceOf[T0]: T0

def children(cs: OParser[_, C]*): OParser[A, C]

def clone(): AnyRef

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

def flatMap(f: (Unit) ⇒ OParser[_, C]): OParser[A, C]

def foreach(f: (Unit) ⇒ Unit): Unit

final def getClass(): Class[_]

def hashCode(): Int

def hidden(): OParser[A, C]

final def isInstanceOf[T0]: Boolean

def keyName(x: String): OParser[A, C]

def keyValueName(k: String, v: String): OParser[A, C]

def map(f: (Unit) ⇒ Unit): OParser[A, C]

def maxOccurs(n: Int): OParser[A, C]

def minOccurs(n: Int): OParser[A, C]

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def optional(): OParser[A, C]

def required(): OParser[A, C]

def subHead[B](head: OptionDef[B, C]): OParser[B, C]

final def synchronized[T0](arg0: ⇒ T0): T0

def text(x: String): OParser[A, C]

def toList: List[OptionDef[_, C]]

def toString(): String

def unbounded(): OParser[A, C]

def validate(f: (A) ⇒ Either[String, Unit]): OParser[A, C]

def valueName(x: String): OParser[A, C]

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

Inherited from AnyRef

Inherited from Any

Ungrouped