ValueReader instance for Either[L,R]

.travis.yml

@@ -1,9 +1,22 @@
 language: scala
+sudo: required
+dist: trusty
+
 scala:
-  - 2.11.0
+  - 2.10.6
+  - 2.11.8
+  - 2.12.0
 jdk:
-  - openjdk7
-  - oraclejdk7
+  - oraclejdk8
+  - openjdk8
+cache:
+  directories:
+  - $HOME/.ivy2/cache
+  - $HOME/.sbt/boot/
 
 install: /bin/true
-script: ./sbt -J-Xss1M -J-Xms512M -J-Xmx512M -J-XX:MaxPermSize=128M ";clean;compile;test"
+
+script:
+  - sbt ++$TRAVIS_SCALA_VERSION mimaReportBinaryIssues
+  - sbt ++$TRAVIS_SCALA_VERSION -jvm-opts travis-jvmopts clean coverage test coverageReport
+  - sbt ++$TRAVIS_SCALA_VERSION coveralls

README.md

@@ -1,25 +1,27 @@
-# Warning: abandoned project #
-I have been neglecting Ficus for several reasons:
-* At work we use [knobs](http://oncue.github.io/knobs/)
-* I am a bit oversubscribed on open source projects
-* Ficus scratched an itch when I first wrote it, but if I were to write it again right now, I would approach it differently.
-    * I would represent errors explicitly in the types (currently it throws exceptions, which can be handy, but I would want an alternative).
-    * I would use [Shapeless](https://github.com/milessabin/shapeless) to derive readers instead of a macro. At the time, the macro was necessary to use default values on classes, but Shapeless now provides full support for this.
-    * I think I would end up writing a `shapeless-knobs` micro library that simply provides Shapeless-derived [Configured](https://github.com/oncue/knobs/blob/master/core/src/main/scala/knobs/Configured.scala) instances.
-
-Having said that, I know there are a number of people that are happily using Ficus. I'm happy to hand this project off to a good owner. The only difficulty might be in publishing credentials. Since its currently under `net.ceedubs`, the simplest option may be to have a fork and start publishing in a different namespace. I'm happy to update the repo to redirect to the new official project. Please email me at my GitHub handle at gmail if you'd like to volunteer to take over this project.
+Official repo for ficus. Adopted from [ceedubs](https://github.com/ceedubs/ficus)
 
 # Ficus #
 Ficus is a lightweight companion to Typesafe config that makes it more Scala-friendly.
 
 Ficus adds an `as[A]` method to a normal [Typesafe Config](http://typesafehub.github.io/config/latest/api/com/typesafe/config/Config.html) so you can do things like `config.as[Option[Int]]`, `config.as[List[String]]`, or even `config.as[MyClass]`. It is implemented with type classes so that it is easily extensible and many silly mistakes can be caught by the compiler.
 
-[![Build Status](https://secure.travis-ci.org/ceedubs/ficus.png?branch=master)](http://travis-ci.org/ceedubs/ficus)
+[![Build Status](https://secure.travis-ci.org/iheartradio/ficus.png?branch=master)](http://travis-ci.org/iheartradio/ficus)
+[![Join the chat at https://gitter.im/iheartradio/ficus](https://badges.gitter.im/iheartradio/ficus.svg)](https://gitter.im/iheartradio/ficus?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
+[![Coverage Status](https://coveralls.io/repos/github/iheartradio/ficus/badge.svg?branch=master)](https://coveralls.io/github/iheartradio/ficus?branch=master)
+[![Latest version](https://index.scala-lang.org/iheartradio/ficus/ficus/latest.svg?color=orange)](https://index.scala-lang.org/iheartradio/ficus)
 
 # Examples #
 ```scala
 import net.ceedubs.ficus.Ficus._
 
+object Country extends Enumeration {
+  val DE = Value("DE")
+  val IT = Value("IT")
+  val NL = Value("NL")
+  val US = Value("US")
+  val GB = Value("GB")
+}
+
 case class SomeCaseClass(foo: String, bar: Int, baz: Option[FiniteDuration])
 
 class Examples {
@@ -37,6 +39,12 @@ class Examples {
   // something such as "15 minutes" can be converted to a FiniteDuration
   val retryInterval: FiniteDuration = config.as[FiniteDuration]("retryInterval")
 
+  // can extract arbitrary Enumeration types
+  // Note: it throws an exception at runtime, if the enumeration type cannot be instantiated or 
+  // if a config value cannot be mapped to the enumeration value
+  import net.ceedubs.ficus.readers.EnumerationReader._
+  val someEnumerationType: Seq[Country.Value] = config.as[Seq[Country.Value]]("countries")
+
   // can hydrate most arbitrary types
   // it first tries to use an apply method on the companion object and falls back to the primary constructor
   // if values are not in the config, they will fall back to the default value on the class/apply method
@@ -48,24 +56,26 @@ class Examples {
 For more detailed examples and how they match up with what's defined in a config file, see [the example spec](https://github.com/ceedubs/ficus/blob/master/src/test/scala/net/ceedubs/ficus/ExampleSpec.scala).
 
 # Adding the dependency #
-You most likely already have the Sonatype OSS Releases repository defined in your build, but if you don't, add this to your SBT build file (most likely build.sbt or project/build.scala):
-```scala
-resolvers ++= Seq(
-  "Sonatype OSS Releases"  at "http://oss.sonatype.org/content/repositories/releases/",
-)
-```
+
 
 Now add the Ficus dependency to your build SBT file as well:
 ```scala
 // for Scala 2.10.x
-libraryDependencies += "net.ceedubs" %% "ficus" % "1.0.1"
+libraryDependencies += "com.iheart" %% "ficus" % "1.0.2"
+
+// for Scala 2.11.x and Java 7
+libraryDependencies += "com.iheart" %% "ficus" % "1.1.3"
 
-// for Scala 2.11.x
-libraryDependencies += "net.ceedubs" %% "ficus" % "1.1.2"
+// for Scala 2.11.x, 2.12.x and Java 8
+// See the latest version in the download badge below.
+libraryDependencies += "com.iheart" %% "ficus" % <latest version> //see latest version in the badge below
 ```
+
+[![Latest version](https://index.scala-lang.org/iheartradio/ficus/ficus/latest.svg?color=orange)](https://index.scala-lang.org/iheartradio/ficus)
+
 If you want to take advantage of Ficus's ability to automatically hydrate arbitrary traits and classes from configuration, you need to be on Scala version 2.10.2 or higer, because this functionality depends on implicit macros.
 
-Release notes are available on the [Ficus wiki](https://github.com/ceedubs/ficus/wiki).
+
 
 # Built-in readers #
 Out of the box, Ficus can read most types from config:
@@ -75,25 +85,53 @@ Out of the box, Ficus can read most types from config:
 * Collections (`List[A]`, `Set[A]`, `Map[String, A]`, `Array[A]`, etc. All types with a CanBuildFrom instance are supported)
 * `Config` and `ConfigValue` (Typesafe config/value)
 * `FiniteDuration`
+* The Scala `Enumeration` type.  See [Enumeration support](#enumeration-support)
 * Most arbitrary classes (as well as traits that have an apply method for instantiation). See [Arbitrary type support](#arbitrary-type-support)
 
 In this context, `A` means any type for which a `ValueReader` is already defined. For example, `Option[String]` is supported out of the box because `String` is. If you want to be able to extract an `Option[Foo[A]]` for some some type `Foo` that doesn't meet the supported type requirements (for example, this `Foo` has a type parameter), the option part is taken care of, but you will need to provide the implementation for extracting a `Foo[A]` from config. See [Custom extraction](#custom-extraction).
 
 # Imports #
 The easiest way to start using Ficus config is to just `import net.ceedubs.ficus.Ficus._` as was done in the Examples section. This will import all of the implicit values you need to start easily grabbing most basic types out of config using the `as` method that will become available on Typesafe `Config` objects.
 
+To enable Ficus's reading of `Enumeration` types, you can also import `net.ceedubs.ficus.readers.EnumerationReader._`. See [Enumeration support](#enumeration-support)
+
 To enable Ficus's macro-based reading of case classes and other types, you can also import `net.ceedubs.ficus.readers.ArbitraryTypeReader._`. See [Arbitrary type support](#arbitrary-type-support)
 
 If you would like to be more judicial about what you import (either to prevent namespace pollution or to potentially speed up compile times), you are free to specify which imports you need.
 
 You will probably want to `import net.ceedubs.ficus.Ficus.toFicusConfig`, which will provide an implicit conversion from Typesafe `Config` to `FicusConfig`, giving you the `as` method.
 
-You will then need a [ValueReader](https://github.com/ceedubs/ficus/blob/master/src/main/scala/net/ceedubs/ficus/readers/ValueReader.scala) for each type that you want to grab using `as`. You can choose whether you would like to get the reader via an import or a mixin Trait. For example, if you want to be able to call `as[String]`, you can either `import net.ceedubs.ficus.FicusConfig.stringValueReader` or you can add `with net.ceedubs.ficus.readers.StringReader` to your class definition.
+You will then need a [ValueReader](https://github.com/iheartradio/ficus/blob/master/src/main/scala/net/ceedubs/ficus/readers/ValueReader.scala) for each type that you want to grab using `as`. You can choose whether you would like to get the reader via an import or a mixin Trait. For example, if you want to be able to call `as[String]`, you can either `import net.ceedubs.ficus.FicusConfig.stringValueReader` or you can add `with net.ceedubs.ficus.readers.StringReader` to your class definition.
 
 If instead you want to be able to call `as[Option[String]]`, you would need to bring an implicit `ValueReader` for `Option` into scope (via `import net.ceedubs.ficus.FicusConfig.optionValueReader` for example), but then you would also need to bring the `String` value reader into scope as described above, since the `Option` value reader delegates through to the relevant value reader after checking that a config value exists at the given path.
 
 _Don't worry_. It will be obvious if you forgot to bring the right value reader into scope, because the compiler will give you an error.
 
+# Enumeration support #
+Ficus has the ability to parse config values to Scala's `Enumeration` type.
+
+If you have the following enum:
+```scala
+object Country extends Enumeration {
+  val DE = Value("DE")
+  val IT = Value("IT")
+  val NL = Value("NL")
+  val US = Value("US")
+  val GB = Value("GB")
+}
+```
+
+You can define the config like:
+```
+countries = [DE, US, GB]
+```
+
+To get an `Enumeration` type from your config you must import the `EnumerationReader` into your code. Then you can fetch it with the `as` method that Ficus provides on Typesafe `Config` objects.
+```scala
+import net.ceedubs.ficus.readers.EnumerationReader._
+val countries: Seq[Country.Value] = config.as[Seq[Country.Value]]("countries")
+```
+
 # Arbitrary type support #
 
 ## Supported types ##
@@ -107,13 +145,25 @@ If it exists, a valid apply method will be used instead of a constructor.
 
 If Ficus doesn't know how to read an arbitrary type, it will provide a helpful **compile-time** error message explaining why. It won't risk guessing incorrectly.
 
-Arbitrary type support requires Scala 2.10.2 or higher, because it takes advantage of implicit macros. To enable it, import `net.ceedubs.ficus.readers.ArbitraryTypeReader._`. Note that having the arbitrary type reader in scope can cause some implicit shadowing that you might not expect. If you define `MyClass` and define an `implicit val myClassReader: ValueReader[MyClass]` in the `MyClass` companion object, the arbitray type reader will still win the implicit prioritization battle unless you specifically `import MyClass.myClassReader`.
+Arbitrary type support requires Scala 2.10.2 or higher, because it takes advantage of implicit macros. To enable it, import `net.ceedubs.ficus.readers.ArbitraryTypeReader._`. Note that having the arbitrary type reader in scope can cause some implicit shadowing that you might not expect. If you define `MyClass` and define an `implicit val myClassReader: ValueReader[MyClass]` in the `MyClass` companion object, the arbitrary type reader will still win the implicit prioritization battle unless you specifically `import MyClass.myClassReader`.
+
+By default the config keys has to match exactly the field name in the class, which by java convention is camel cased. To enable hyphen cased mapping, i.e. hyphen cased config keys, you can import a hyphen cased name mapper into the scope, such as:
+
+```scala
+import net.ceedubs.ficus.readers.namemappers.implicits.hyphenCase
+```
 
 # Custom extraction #
 When you call `as[String]("somePath")`, Ficus config knows how to extract a String because there is an implicit `ValueReader[String]` in scope. If you would like, you can even teach it how to extract a `Foo` from the config using `as[Foo]("fooPath")` if you create your own `ValueReader[Foo]`. You could pass this Foo extractor explicitly to the `as` method, but most likely you just want to make it implicit. For an example of a custom value reader, see the `ValueReader[ServiceConfig]` defined in [ExampleSpec](https://github.com/ceedubs/ficus/blob/master/src/test/scala/net/ceedubs/ficus/ExampleSpec.scala).
 
 # Contributions #
 
-Many thanks to all of [those who have contributed](https://github.com/ceedubs/ficus/blob/master/CONTRIBUTORS.md) to Ficus.
+Many thanks to all of [those who have contributed](https://github.com/iheartradio/ficus/blob/master/CONTRIBUTORS.md) to Ficus.
+
+Would you like to contribute to Ficus? Pull requests are welcome and encouraged! Please note that contributions will be under the [MIT license](https://github.com/iheartradio/ficus/blob/master/LICENSE). Please provide unit tests along with code contributions.
+
+
+
+## Binary Compatibility
 
-Would you like to contribute to Ficus? Pull requests are welcome and encouraged! Please note that contributions will be under the [MIT license](https://github.com/ceedubs/ficus/blob/master/LICENSE). Please provide unit tests along with code contributions.
+[MiMa](https://github.com/typesafehub/migration-manager) can be used to check the binary compatibility between two versions of a library.T To check for binary incompatibilities, run `mimaReportBinaryIssues` in the sbt repl. The build is configured to compare the current version against the last released version (It does this naïvely at the moment by merely decrementing bugfix version). If any binary compatibility issues are detected, you may wish to adjust your code to maintain binary compatibility, if that is the goal, or modify the minor version to indicate to consumers that the new version should not be considered binary compatible.

build.sbt

@@ -1,73 +1,53 @@
+import sbtrelease.Version
+
 /* basic project info */
 name := "ficus"
 
-organization := "net.ceedubs"
-
 description := "A Scala-friendly wrapper companion for Typesafe config"
 
-homepage := Some(url("https://github.com/ceedubs/ficus"))
-
 startYear := Some(2013)
 
-licenses := Seq(
-  "MIT License" -> url("http://www.opensource.org/licenses/mit-license.html")
-)
-
-scmInfo := Some(
-  ScmInfo(
-    url("https://github.com/ceedubs/ficus"),
-    "scm:git:https://github.com/ceedubs/ficus.git",
-    Some("scm:git:[email protected]:ceedubs/ficus.git")
-  )
-)
-
 /* scala versions and options */
-scalaVersion := "2.11.0"
+scalaVersion := "2.12.0"
+
+crossScalaVersions := Seq(scalaVersion.value, "2.10.6", "2.11.8")
 
 // These options will be used for *all* versions.
 scalacOptions ++= Seq(
+  "-feature",
   "-deprecation",
   "-unchecked",
-  "-encoding", "UTF-8"
-)
+  "-encoding", "UTF-8",
+  "-target:jvm-1." + {
+    CrossVersion.partialVersion(scalaVersion.value).collect {
+      case (2, minor) if minor <= 10 => "7"
+    }.getOrElse("8")
+  }
+) ++ (if (scalaVersion.value.startsWith("2.11") || scalaVersion.value.startsWith("2.10")) Seq("-Yclosure-elim", "-Yinline") else Seq.empty[String])
 
-scalacOptions ++= Seq(
-  "-Yclosure-elim",
-  "-Yinline"
+javacOptions ++= Seq(
+  "-Xlint:unchecked", "-Xlint:deprecation"
 )
 
-// These language flags will be used only for 2.10.x.
-// Uncomment those you need, or if you hate SIP-18, all of them.
-scalacOptions <++= scalaVersion map { sv =>
-  if (sv startsWith "2.10") List(
-    "-Xverify",
-    "-Ywarn-all",
-    "-feature",
-    "-language:postfixOps",
-    "-language:implicitConversions",
-    "-language:higherKinds"
-  )
-  else Nil
-}
-
-javacOptions ++= Seq("-Xlint:unchecked", "-Xlint:deprecation")
-
 /* dependencies */
-libraryDependencies <++= scalaVersion { sv =>
-  Seq(
-    "org.specs2"     %% "specs2"         % "2.3.11"   % "test",
-    "org.scalacheck" %% "scalacheck"     % "1.11.3"   % "test",
-    "com.chuusai"    %% "shapeless"      % "2.0.0"    % "test",
-    "com.typesafe"   %  "config"         % "1.2.1",
-    "org.scala-lang" %  "scala-reflect"  % sv         % "provided")
-}
+libraryDependencies ++= Seq(
+  "org.specs2"     %% "specs2-core"       % "3.8.6"  % "test",
+  "org.specs2"     %% "specs2-scalacheck" % "3.8.6"  % "test",
+  "org.scalacheck" %% "scalacheck"        % "1.13.4" % "test",
+  "com.chuusai"    %% "shapeless"         % "2.3.2"  % "test",
+  "com.typesafe"   %  "config"            % "1.3.1",
+  "org.scala-lang" %  "scala-reflect"     % scalaVersion.value % "provided",
+  "org.scala-lang" % "scala-compiler"     % scalaVersion.value % "provided",
+  "org.typelevel"  %% "macro-compat"      % "1.1.1",
+  compilerPlugin("org.scalamacros" % "paradise" % "2.1.0" cross CrossVersion.full)
+)
 
-/* you may need these repos */
 resolvers ++= Seq(
-  Resolver.sonatypeRepo("snapshots")
+  Resolver.sonatypeRepo("snapshots"),
+  Resolver.bintrayRepo("iheartradio","maven"),
+  Resolver.jcenterRepo
 )
 
-/* testing */
 parallelExecution in Test := true
 
 /* sbt behavior */
@@ -77,33 +57,22 @@ traceLevel := 5
 
 offline := false
 
-/* publishing */
-publishMavenStyle := true
-
-publishTo <<= version { (v: String) =>
-  val nexus = "https://oss.sonatype.org/"
-  if (v.trim.endsWith("SNAPSHOT")) Some(
-    "snapshots" at nexus + "content/repositories/snapshots"
-  )
-  else Some("releases" at nexus + "service/local/staging/deploy/maven2")
-}
-
-mappings in (Compile, packageBin) ~= { (ms: Seq[(File, String)]) =>
-  ms filter { case (file, toPath) =>
-      toPath != "application.conf"
+mappings in (Compile, packageBin) := {
+  val ms = mappings.in(Compile, packageBin).value
+  ms filter { case (_, toPath) =>
+    toPath != "application.conf"
   }
 }
 
-publishArtifact in Test := false
+Publish.settings
 
-pomIncludeRepository := { _ => false }
+releaseCrossBuild := true
+
+mimaPreviousArtifacts := (if (scalaBinaryVersion.value != "2.10") {
+  Version(version.value).map {
+    case Version(major, subversions, _) =>
+      val (minor :: bugfix :: _) = subversions.toList
+      Set(organization.value %% name.value % Seq(major, minor, bugfix - 1).mkString("."))
+  }.getOrElse(Set.empty)
+} else Set.empty)
 
-pomExtra := (
-  <developers>
-    <developer>
-      <id>ceedubs</id>
-      <name>Cody Allen</name>
-      <email>[email protected]</email>
-    </developer>
-  </developers>
-)