Review First: SDK Update (#149)

* update Dict.update function to take an alter function

* update Aggregate.scala with missing functions and mismatched types

* update sdk functions

* align sdk.Regex more closely with elm\/regex

* - Revert Result.map3 param signature to `fn: (A, B, C) => V`
- change counter implementation for Regex.find

* added unit test for Regex.find and Regex.split

.scalafmt.conf

@@ -18,7 +18,7 @@ rewrite.rules = [RedundantBraces]
 
 project.excludeFilters = []
 # Defaults
-project.excludePaths = ["glob:**/ir/src-2.12/morphir/ir/**.scala", "glob:**/ir/src-2.13/morphir/ir/**.scala", "glob:**/ir/src/morphir/ir/**.scala" ,"glob:**/DAG.scala"]
+project.excludePaths = ["glob:**/ir/src-2.12/morphir/ir/**.scala", "glob:**/ir/src-2.13/morphir/ir/**.scala", "glob:**/ir/src/morphir/ir/**.scala" ,"glob:**/ir/src/morphir/dependency/**.scala"]
 
 
 rewrite.redundantBraces.generalExpressions = false

morphir/sdk/core/src/morphir/sdk/Decimal.scala

@@ -115,6 +115,8 @@ object Decimal extends DecimalModuleCompat {
   //TODO: Make sure the Elm call and this call return the same value
   def toString(value: Decimal): morphir.sdk.String.String = value.toString
 
+  def _toString: Decimal => String = toString
+
   def truncate(decimal: Decimal): Decimal =
     decimal.setScale(0, BigDecimal.RoundingMode.DOWN)
 

morphir/sdk/core/src/morphir/sdk/Regex.scala

@@ -18,18 +18,47 @@ package morphir.sdk
 
 import morphir.sdk.Maybe.Maybe
 
+import scala.util.Try
 import scala.util.matching.{ Regex => RE }
 
 object Regex {
 
   case class Regex(toRE: RE) extends AnyVal
   case class Options(caseInsensitive: Boolean, multiline: Boolean)
   case class Match(
-    `match`: String,
+    _match: String,
     index: Int,
     number: Int,
     submatches: List[Maybe[String]]
   )
 
   val never: Regex = Regex(".^".r)
+
+  def fromString(string: String): Maybe[Regex] =
+    Try(string.r).toOption.map(Regex.apply)
+
+  def split(regex: Regex)(string: String): List[String] =
+    regex.toRE.split(string).toList
+
+  /** Find matches in a string:
+    *
+    * val location: Regex.Regex = Maybe.withDefault(never)(fromString "[oi]n a (\\w+)")
+    *
+    * val places : List[Regex.Match places = Regex.find location "I am on a boat in a lake."
+    *
+    * // places.map(_.match) == List( "on a boat", "in a lake" ) // places.map(_.submatches) == List( List(Just "boat"),
+    * List(Just "lake") )
+    *
+    * > Note: .submatches will always return an empty list
+    */
+  def find(regex: Regex)(str: String): List[Match] =
+    regex.toRE.findAllMatchIn(str).toList.zipWithIndex.map { case (mtch, idx) =>
+      Match(
+        _match = mtch.matched,
+        index = mtch.start,
+        number = idx + 1,
+        submatches = mtch.subgroups.map(Maybe.Just(_))
+      )
+    }
+
 }

morphir/sdk/core/src/morphir/sdk/ResultList.scala

@@ -0,0 +1,24 @@
+package morphir.sdk
+
+object ResultList {
+
+  type ResultList[E, A] = List.List[Result.Result[E, A]]
+
+  /** Turn a list of results into a single result keeping all errors.
+    */
+  def keepAllErrors[E, A](results: ResultList[E, A]): Result.Result[List[E], List[A]] = {
+    val oks: List[A] = List.filterMap(Result.toMaybe[E, A])(results)
+    val errs: List[E] = List.filterMap((result: Result[E, A]) =>
+      result match {
+        case Result.Err(e) => Maybe.Just(e)
+        case Result.Ok(_)  => Maybe.Nothing
+      }
+    )(results)
+
+    errs match {
+      case Nil => Result.Ok(oks)
+      case _   => Result.Err(errs)
+    }
+  }
+
+}

morphir/sdk/core/test/src/morphir/sdk/RegexSpec.scala

@@ -0,0 +1,48 @@
+package morphir.sdk
+
+import zio.test._
+
+object RegexSpec extends DefaultRunnableSpec {
+
+  val splitPattern: Regex.Regex =
+    Maybe.withDefault(Regex.never)(Regex.fromString("""[^\w\s]+"""))
+
+  val splitScenarios = Seq(
+    ("morphir.sdk", List("morphir", "sdk")),
+    ("morphir:sdk", List("morphir", "sdk"))
+  )
+
+  val wordPattern: Regex.Regex =
+    Maybe.withDefault(Regex.never)(Regex.fromString("""([a-zA-Z][a-z]*|[0-9]+)"""))
+
+  val findScenarios = Seq(
+    ("Morphir", List("Morphir")),
+    ("SDK", List("S", "D", "K")),
+    ("camelCaseName", List("camel", "Case", "Name"))
+  )
+
+  def spec = suite("Regex Spec")(
+    suite(s"""Regex.split with $splitPattern pattern""")(
+      splitScenarios.map { case (testString, expectedOutput) =>
+        test(s"""split("$testString") == $expectedOutput""") {
+          assert(Regex.split(splitPattern)(testString))(
+            Assertion.equalTo(expectedOutput)
+          )
+        }
+      }: _*
+    ),
+    suite(s"""Regex.find with $wordPattern pattern""")(
+      findScenarios.map { case (testString, expectedOutput) =>
+        test(s"""find("$testString").map(_.match) == $expectedOutput""") {
+          assert(
+            Regex
+              .find(wordPattern)(testString)
+              .map(_._match)
+          )(
+            Assertion.equalTo(expectedOutput)
+          )
+        }
+      }: _*
+    )
+  )
+}