Add a withOverrides method to ConfigFieldMapping

CHANGELOG.md

@@ -1,3 +1,9 @@
+### 0.7.3 (unreleased)
+
+- New features
+  - `ConfigFieldMapping` now has a `withExceptions` method that allows users to easily define exceptions to an existing
+    mapping.
+
 ### 0.7.2 (May 29, 2017)
 
 - Bug fixes

core/src/main/scala/pureconfig/ConfigFieldMapping.scala

@@ -1,10 +1,27 @@
 package pureconfig
 
+/**
+ * A mapping between case class fields and their respective keys in the config.
+ */
 trait ConfigFieldMapping extends (String => String) {
+
   def apply(fieldName: String): String
+
+  /**
+   * Returns a `ConfigFieldMapping` that uses this mapping with some exceptions.
+   *
+   * @param exceptions the exceptions for this mapping as pairs (field, configKey)
+   * @return a `ConfigFieldMapping` that maps fields using `exceptions` if the field is present there and otherwise
+   *         uses this mapping.
+   */
+  def withExceptions(exceptions: (String, String)*) = {
+    val map = exceptions.toMap
+    ConfigFieldMapping { field => map.getOrElse(field, this.apply(field)) }
+  }
 }
 
 object ConfigFieldMapping {
+
   /**
    * Creates a ConfigFieldMapping from the provided function, mapping names in
    * the object that will receive config values to names in the configuration
@@ -32,9 +49,9 @@ object ConfigFieldMapping {
    */
   def apply(typeFieldConvention: NamingConvention, configFieldConvention: NamingConvention): ConfigFieldMapping = {
     if (typeFieldConvention == configFieldConvention) {
-      apply(identity(_))
+      apply(identity)
     } else {
-      apply(typeFieldConvention.toTokens _ andThen configFieldConvention.fromTokens _)
+      apply(typeFieldConvention.toTokens _ andThen configFieldConvention.fromTokens)
     }
   }
 }

core/src/test/scala/pureconfig/ConfigFieldMappingSuite.scala

@@ -0,0 +1,28 @@
+package pureconfig
+
+import org.scalatest.{ FlatSpec, Matchers }
+
+class ConfigFieldMappingSuite extends FlatSpec with Matchers {
+
+  behavior of "ConfigFieldMapping"
+
+  it should "allow defining a mapping using a function" in {
+    val mapping = ConfigFieldMapping(_.replace("Field", "ConfigKey"))
+    mapping("theBeautifulField") === "theBeautifulConfigKey"
+    mapping("theUglyFld") === "theUglyFld"
+  }
+
+  it should "allow defining a mapping between two naming conventions" in {
+    val mapping = ConfigFieldMapping(CamelCase, SnakeCase)
+    mapping("theBeautifulField") === "the_beautiful_field"
+    mapping("theUglyFld") === "the_ugly_fld"
+  }
+
+  it should "allow defining mappings with some exceptions" in {
+    val mapping = ConfigFieldMapping(CamelCase, SnakeCase).withExceptions(
+      "theUglyFld" -> "the_ugly_field")
+
+    mapping("theBeautifulField") === "the_beautiful_field"
+    mapping("theUglyFld") === "the_ugly_field"
+  }
+}