Packages

  • package root
    Definition Classes
    root
  • package args4c

    Args4c (arguments for configuration) is intended to add some helpers and utilities in obtaining a typesafe configuration from user arguments.

    Args4c (arguments for configuration) is intended to add some helpers and utilities in obtaining a typesafe configuration from user arguments.

    The core is simply to convert an Array[String] to a Config where the arguments are either paths to configuration resources or simple key=value pairs via args4c.configForArgs

    Left-most arguments take precedence. In this example, we assume 'prod.conf' is a resource on the classpath:

    MyApp foo.x=bar foo.x=ignored /opt/etc/overrides.conf prod.conf

    In addition to this core concept, this library also provides some additional configuration utilities via args4c.RichConfigOps which can be made available by extending args4c.LowPriorityArgs4cImplicits or importing args4c.implicits:

    import args4c.implicits._
object MyApp {
   override def main(args : Array[String]) : Unit = {
     val config = args.asConfig()
     println("Starting MyApp with config:")

     // let's "log" our app's config on startup:
     val flatSummary : String = config.filter(_.startsWith("myapp")).summary()
     println(flatSummary) // "logging" our config
   }
}

    Where the 'summary' will produce sorted args4c.StringEntry values with potentially sensitive entries (e.g. passwords) obscured and a source comment for some sanity as to where each entry comes from:

    myapp.foo : bar # command-line
myapp.password : **** obscured **** # command-line
myapp.saveTo : afile # file:/opt/etc/myapp/test.conf@3

    Also, when extracting user arguments into a configuration, an additional 'fallback' config is specified. Typically this would just be the ConfigFactory.load() configuration, but args4c uses the args4c.defaultConfig, which is essentially just the system environment variables converted from snake-caes to dotted lowercase values first, then falling back on ConfigFactory.load().

    Applications can elect to not have this behaviour and provide their own fallback configs when parsing args, but the default provides a convenience for system environment variables to override e.g. 'foo.bar.x=default' by specifying

    FOO_BAR_X=override

    as a system environment variable. Otherwise you may end up having to repeat this sort of thing all over you config:

    foo.bar=default
foo.bar=$${?FOO_BAR}

foo.bazz=default2
foo.bazz=$${?FOO_BAZZ}

...

    Finally, args4c also provides a args4c.ConfigApp which provides some additional functionality to configuration-based applications.

    Definition Classes
    root
  • ConfigApp
  • Encryption
  • LowPriorityArgs4cImplicits
  • PasswordPrompt
  • Prompt
  • PromptForConfigFilePermissions
  • PromptForExistingPassword
  • PromptForPassword
  • PromptForUpdatedPassword
  • ReadNextKeyValuePair
  • ReadNextKeyValuePairAfterError
  • RichConfig
  • RichConfigOps
  • SaveSecretPrompt
  • SecureConfig
  • Selected
  • StringEntry
  • implicits
t

args4c

RichConfigOps

trait RichConfigOps extends Dynamic with LowPriorityArgs4cImplicits

Exposes new operations on a 'config'

Linear Supertypes
LowPriorityArgs4cImplicits, Dynamic, AnyRef, Any
Known Subclasses
RichConfig
Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. RichConfigOps
  2. LowPriorityArgs4cImplicits
  3. Dynamic
  4. AnyRef
  5. Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. All

Type Members

  1. implicit class RichArgs extends AnyRef
    Definition Classes
    LowPriorityArgs4cImplicits
  2. implicit class RichString extends AnyRef
    Definition Classes
    LowPriorityArgs4cImplicits

Abstract Value Members

  1. abstract def config: Config

    returns

    the configuration for which we're providing additional functionality

Concrete Value Members

  1. final def !=(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  2. final def ##(): Int
    Definition Classes
    AnyRef → Any
  3. final def ==(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  4. def asDuration(key: String): Duration

    key

    the configuration path

    returns

    the value at the given key as a scala duration

  5. def asFiniteDuration(key: String): FiniteDuration
  6. final def asInstanceOf[T0]: T0
    Definition Classes
    Any
  7. def asJson: String

    returns

    the configuration as a json string

  8. def asList(path: String, separator: Option[String] = Option(",")): List[String]

    produces a scala list, either from a StringList or a comma-separated string value

    produces a scala list, either from a StringList or a comma-separated string value

    path

    the config path

    separator

    if specified, the value at the given path will be parsed if it is a string and not a stringlist

  9. def clone(): AnyRef
    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.CloneNotSupportedException]) @native()
  10. def collectAsMap(options: ConfigRenderOptions = defaultRenderOptions): Map[String, String]

    returns

    the configuration as a map

  11. def collectAsStrings(options: ConfigRenderOptions = defaultRenderOptions): Seq[(String, String)]

    returns

    the configuration as a set of key/value tuples

  12. implicit def configAsRichConfig(c: Config): RichConfig
    Definition Classes
    LowPriorityArgs4cImplicits
  13. def defaultRenderOptions: ConfigRenderOptions
  14. def encrypt(password: Array[Byte]): Array[Byte]

    returns

    the encrypted configuration

  15. def entries(arraySyntax: Boolean = true): Set[(String, ConfigValue)]

    arraySyntax

    if true expand arrays with '.[x]' syntax

    returns

    the configuration entries as a set of entries

  16. final def eq(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  17. def equals(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef → Any
  18. def filter(pathFilter: (String) => Boolean): Config

    pathFilter

    a predicate used to determine if the configuration path should be kept

    returns

    a new configuration which just keeps the paths which include the provided path predicate

  19. def filterNot(pathFilter: (String) => Boolean): Config

    pathFilter

    a predicate used to determine if the configuration path should be kept

    returns

    a new configuration which just keeps the paths which do NOT include the provided path predicate

  20. def finalize(): Unit
    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.Throwable])
  21. final def getClass(): Class[_ <: AnyRef]
    Definition Classes
    AnyRef → Any
    Annotations
    @native()
  22. def hasValue(path: String): Boolean

    path

    the config path

    returns

    true if the config path is set in this config to a non-empty value. This will error if the path specified is an object or a list

  23. def hashCode(): Int
    Definition Classes
    AnyRef → Any
    Annotations
    @native()
  24. def intersect(other: Config): Config

    returns

    the configuration representing the intersection of the two configuration entries

  25. final def isInstanceOf[T0]: Boolean
    Definition Classes
    Any
  26. final def ne(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  27. final def notify(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native()
  28. final def notifyAll(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native()
  29. def origins: List[String]

    returns

    a sorted list of the origins from when the config values come

  30. def overrideWith(configString: String): Config

    configString

    the configuration (as a string) which should override this config -- essentially the inverse of 'withFallback'

    returns

    a new configuration based on 'configString' with our config as a fallback

  31. def overrideWith(overrideConfig: Config): Config

    overrideConfig

    the configuration (as a string) which should override this config -- essentially the inverse of 'withFallback'

    returns

    a new configuration based on 'configString' with our config as a fallback

  32. def pathRoots: Seq[String]

    The available config roots.

    The available config roots.

    e.g. of a config has

    foo.bar.x = 1
java.home = /etc/java
bar.enabled = true
bar.user = root

    The 'pathRoots' would return a [bar, foo, java]

    returns

    a sorted list of the root entries to the config.

  33. def paths(arraySyntax: Boolean = true): Seq[String]

    returns

    all the unique paths for this configuration

  34. def selectDynamic(path: String): Selected
  35. def set(values: Map[String, Any], originDesc: String = "override"): Config
  36. def set(key: String, value: Boolean): Config
  37. def set(key: String, value: String): Config
  38. def set(key: String, value: Long): Config

    key

    the config path

    value

    the value to set

    returns

    a new configuration based on 'configString' with our config as a fallback

  39. def setArray[T](key: String, value: Seq[T], originDesc: String = null): Config
  40. def setArray[T](key: String, firstValue: T, secondValue: T, theRest: T*): Config
  41. def showIfSpecified(obscure: (String, String) => String = obscurePassword(_, _)): Option[String]

    If 'show=X' is specified, configuration values which contain X in their path will be displayed with the values matching 'obscure' obscured.

    If 'show=X' is specified, configuration values which contain X in their path will be displayed with the values matching 'obscure' obscured.

    If 'X' is 'all' or 'root', then the entire configuration is rendered.

    This can be useful to debug other command-line args (to ensure they take the desired effect) or to validate the environment variable replacement

    obscure

    a function which takes a dotted configuration path and string value and returns the value to display

    returns

    the optional value of what's pointed to if 'show=<path>' is specified

  42. def summary(obscure: (String, String) => String = obscurePassword(_, _)): String

    Return a property-like summary of the config using the pathFilter to trim property entries

    Return a property-like summary of the config using the pathFilter to trim property entries

    obscure

    a function which will 'safely' replace any config values with an obscured value

    returns

    a summary of the configuration

  43. def summaryEntries(obscure: (String, String) => String = obscurePassword(_, _)): Seq[StringEntry]

    Return a property-like summary of the config using the 'obscure' function to mask sensitive entries

    Return a property-like summary of the config using the 'obscure' function to mask sensitive entries

    obscure

    a function which will 'safely' replace any config values with an obscured value

  44. final def synchronized[T0](arg0: => T0): T0
    Definition Classes
    AnyRef
  45. def toMap: Map[String, ConfigValue]

    returns

    the config as a map

  46. def toString(): String
    Definition Classes
    AnyRef → Any
  47. final def wait(): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException])
  48. final def wait(arg0: Long, arg1: Int): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException])
  49. final def wait(arg0: Long): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException]) @native()
  50. def withPaths(paths: Seq[String]): Config

    returns

    this configuration which only contains the specified paths

  51. def withPaths(first: String, theRest: String*): Config

    first

    the first path to include (keep)

    theRest

    any other paths to keep

    returns

    this configuration which only contains the specified paths

  52. def withUserArgs(args: Array[String], unrecognizedArg: (String) => Config = ParseArg.Throw): Config

    Overlay the given arguments over this configuration, where the arguments are taken to be in the form:

    Overlay the given arguments over this configuration, where the arguments are taken to be in the form:

    $ the path to a configuration file, either on the classpath or file system $ a <key>=<value> pair where the key is a 'path.to.a.configuration.entry'

    args

    the user arguments in the form <key>=<value>, <filePath> or <fileOnTheClasspath>

    unrecognizedArg

    what to do with malformed user input

    returns

    a configuration with the given user-argument overrides applied over top

  53. def without(configPaths: TraversableOnce[String]): Config

    configPaths

    the paths to remove

    returns

    a new configuration with the given paths removed

  54. def without(firstPath: String, theRest: String*): Config

    firstPath

    the first path to remove

    theRest

    the remaining paths to remove

    returns

    a new configuration with the given paths removed

  55. def without(other: Config): Config

    other

    the configuration to remove from this config

    returns

    a new configuration with all values from 'other' removed

Inherited from LowPriorityArgs4cImplicits

Inherited from Dynamic

Inherited from AnyRef

Inherited from Any

Ungrouped