Fix bug with previous commit

Author: loverdos

src/main/scala/com/ckkloverdos/props/Props.scala

@@ -44,127 +44,127 @@ class Props(val map: Map[String, String])(implicit conv: Converters = Converters
 
   def getBoolean(key: String): Maybe[Boolean] = map.get(key) match {
     case Some(value) ⇒
-      handleKeyError(key, conv.convertToBoolean(value))
+      handleKeyLookup(key, conv.convertToBoolean(value))
 
     case None ⇒
       NoVal
   }
 
   def getBooleanEx(key: String): Boolean = map.get(key) match {
     case Some(value) ⇒
-      handleKeyError(key, conv.convertToBooleanEx(value))
+      handleKeyLookupEx(key, conv.convertToBooleanEx(value))
 
     case None ⇒
       throw new IllegalArgumentException("Unknown key %s".format(key))
   }
 
   def getByte(key: String): Maybe[Byte] = map.get(key) match {
     case Some(value) ⇒
-      handleKeyError(key, conv.convertToByte(value))
+      handleKeyLookup(key, conv.convertToByte(value))
 
     case None ⇒
       NoVal
   }
 
   def getByteEx(key: String): Byte = map.get(key) match {
     case Some(value) ⇒
-      handleKeyError(key, conv.convertToByteEx(value))
+      handleKeyLookupEx(key, conv.convertToByteEx(value))
 
     case None ⇒
       throw new IllegalArgumentException("Unknown key %s".format(key))
   }
 
   def getShort(key: String): Maybe[Short] = map.get(key) match {
     case Some(value) ⇒
-      handleKeyError(key, conv.convertToShort(value))
+      handleKeyLookup(key, conv.convertToShort(value))
 
     case None ⇒
       NoVal
   }
 
   def getShortEx(key: String): Short = map.get(key) match {
     case Some(value) ⇒
-      handleKeyError(key, conv.convertToShortEx(value))
+      handleKeyLookupEx(key, conv.convertToShortEx(value))
 
     case None ⇒
       throw new IllegalArgumentException("Unknown key %s".format(key))
   }
 
   def getInt(key: String): Maybe[Int] = map.get(key) match {
     case Some(value) ⇒
-      handleKeyError(key, conv.convertToInt(value))
+      handleKeyLookup(key, conv.convertToInt(value))
 
     case None ⇒
       NoVal
   }
 
   def getIntEx(key: String): Int = map.get(key) match {
     case Some(value) ⇒
-      handleKeyError(key, conv.convertToIntEx(value))
+      handleKeyLookupEx(key, conv.convertToIntEx(value))
 
     case None ⇒
       throw new IllegalArgumentException("Unknown key %s".format(key))
   }
 
   def getLong(key: String): Maybe[Long] = map.get(key) match {
     case Some(value) ⇒
-      handleKeyError(key, conv.convertToLong(value))
+      handleKeyLookup(key, conv.convertToLong(value))
 
     case None ⇒
       NoVal
   }
 
   def getLongEx(key: String): Long = map.get(key) match {
     case Some(value) ⇒
-      handleKeyError(key, conv.convertToLongEx(value))
+      handleKeyLookupEx(key, conv.convertToLongEx(value))
 
     case None ⇒
       throw new IllegalArgumentException("Unknown key %s".format(key))
   }
 
   def getDouble(key: String): Maybe[Double] = map.get(key) match {
     case Some(value) ⇒
-      handleKeyError(key, conv.convertToDouble(value))
+      handleKeyLookup(key, conv.convertToDouble(value))
 
     case None ⇒
       NoVal
   }
 
   def getDoubleEx(key: String): Double = map.get(key) match {
     case Some(value) ⇒
-      handleKeyError(key, conv.convertToDoubleEx(value))
+      handleKeyLookupEx(key, conv.convertToDoubleEx(value))
 
     case None ⇒
       throw new IllegalArgumentException("Unknown key %s".format(key))
   }
 
   def getFloat(key: String): Maybe[Float] = map.get(key) match {
     case Some(value) ⇒
-      handleKeyError(key, conv.convertToFloat(value))
+      handleKeyLookup(key, conv.convertToFloat(value))
 
     case None ⇒
       NoVal
   }
 
   def getFloatEx(key: String): Float = map.get(key) match {
     case Some(value) ⇒
-      handleKeyError(key, conv.convertToFloatEx(value))
+      handleKeyLookupEx(key, conv.convertToFloatEx(value))
 
     case None ⇒
       throw new IllegalArgumentException("Unknown key %s".format(key))
   }
 
   def getProps(key: String): Maybe[Props] = map.get(key) match {
     case Some(value) ⇒
-      handleKeyError(key, conv.convert[Props](value))
+      handleKeyLookup(key, conv.convert[Props](value))
 
     case None ⇒
       NoVal
   }
 
   def getPropsEx(key: String): Props = map.get(key) match {
     case Some(value) ⇒
-      handleKeyError(key, conv.convertEx[Props](value))
+      handleKeyLookupEx(key, conv.convertEx[Props](value))
 
     case None ⇒
       throw new IllegalArgumentException("Unknown key %s".format(key))
@@ -173,7 +173,7 @@ class Props(val map: Map[String, String])(implicit conv: Converters = Converters
 
   def getList(key: String, separatorRegex: String = "\\s*,\\s*") = map.get(key) match {
     case Some(value) ⇒
-      handleKeyError(key, value.split(separatorRegex).toList)
+      handleKeyLookupEx(key, value.split(separatorRegex).toList)
 
     case None ⇒
       Nil

src/main/scala/com/ckkloverdos/props/PropsBase.scala

@@ -17,7 +17,7 @@
 package com.ckkloverdos.props
 
 import com.ckkloverdos.convert.Converters
-import com.ckkloverdos.maybe.Maybe
+import com.ckkloverdos.maybe.{Failed, MaybeEither, Maybe}
 
 
 /**
@@ -63,7 +63,17 @@ trait PropsBase[K, V, P <: PropsBase[K, V,  P]] {
 
   def isEmpty = size == 0
 
-  protected[this] def handleKeyError[A](key: String, f: ⇒ A): A = {
+  protected[this] def handleKeyLookup[A](key: String, f: ⇒ MaybeEither[A]): MaybeEither[A] = {
+    f match {
+      case Failed(e) ⇒
+        Failed(new Exception("For key %s".format(key), e))
+
+      case just ⇒
+        just
+    }
+  }
+
+  protected[this] def handleKeyLookupEx[A](key: String, f: ⇒ A): A = {
     try f
     catch {
       case e: Throwable ⇒