cleanup code

Author: tracyhires

api-check-ignore.xml

@@ -51,4 +51,39 @@
         <from>*</from>
         <to>*</to>
     </difference>
+    <!-- changes from 1.8.1 to 1.9 -->
+    <difference>
+        <className>org/camunda/dmn/DmnEngine</className>
+        <differenceType>7004</differenceType>
+        <method>DmnEngine(*</method>
+    </difference>
+    <difference>
+        <className>org/camunda/dmn/parser/DmnParser</className>
+        <differenceType>7004</differenceType>
+        <method>DmnParser(*</method>
+    </difference>
+    <difference>
+        <className>org/camunda/dmn/parser/ParsedDmn</className>
+        <differenceType>7004</differenceType>
+        <method>*</method>
+    </difference>
+    <difference>
+        <className>org/camunda/dmn/parser/ParsedBusinessKnowledgeModel</className>
+        <differenceType>2000</differenceType>
+    </difference>
+    <difference>
+        <className>org/camunda/dmn/parser/ParsedBusinessKnowledgeModel</className>
+        <differenceType>4001</differenceType>
+        <to>**</to>
+    </difference>
+    <difference>
+        <className>org/camunda/dmn/parser/ParsedDecision</className>
+        <differenceType>2000</differenceType>
+    </difference>
+    <difference>
+        <className>org/camunda/dmn/parser/ParsedDecision</className>
+        <differenceType>4001</differenceType>
+        <to>**</to>
+    </difference>
+    <!-- END changes from 1.8.1 to 1.9 -->
 </differences>

src/main/scala/org/camunda/dmn/evaluation/DecisionEvaluator.scala

@@ -51,7 +51,6 @@ class DecisionEvaluator(
             val decisionEvaluationContext = context.copy(
               variables = context.variables
                 ++ decisionResults ++ functions,
-                //                ++ embeddedFunctions ++ importedFunctions,
                 currentElement = decision)
 
             eval(decision.logic, decisionEvaluationContext)
@@ -77,8 +76,8 @@ class DecisionEvaluator(
     requiredBkms: Iterable[ParsedBusinessKnowledgeModelReference],
     context: EvalContext): Either[Failure, List[(String, Val)]] = {
     mapEither(requiredBkms,
-      (bkm: ParsedBusinessKnowledgeModelReference) => evalBkm(bkm.resolve(), context)
-        .map(maybeWrapResult(bkm, _)))
+      (bkmRef: ParsedBusinessKnowledgeModelReference) => evalBkm(bkmRef.resolve(), context)
+        .map(maybeWrapResult(bkmRef, _)))
   }
 
   private def maybeWrapResult(

src/main/scala/org/camunda/dmn/parser/DmnParser.scala

@@ -69,18 +69,19 @@ object DmnParser {
 }
 
 class DmnParser(
-                 configuration: Configuration,
-                 feelParser: String => Either[String, feel.syntaxtree.ParsedExpression],
-                 feelUnaryTestsParser: String => Either[String,
-                   feel.syntaxtree.ParsedExpression],
-                 dmnRepository: DmnRepository) {
+  configuration: Configuration,
+  feelParser: String => Either[String, feel.syntaxtree.ParsedExpression],
+  feelUnaryTestsParser: String => Either[String,
+    feel.syntaxtree.ParsedExpression],
+  dmnRepository: DmnRepository) {
 
   import DmnParser._
 
   case class ImportedModel(namespace: String, name: String)
 
   case class ModelReference(namespace: String, id: String) {
     def isEmbedded: Boolean = namespace.isEmpty
+
     def isImported: Boolean = !isEmbedded
   }
 
@@ -337,11 +338,11 @@ class DmnParser(
         .find(importedModel => reference.namespace == importedModel.namespace)
         .map(importedModel => ImportedBusinessKnowledgeModel(
           dmnRepository, reference.namespace, reference.id, Some(importedModel.name)))
-          .getOrElse {
-            val failure = Failure(s"No import found for namespace '${reference.namespace}'.")
-            ctx.failures += failure
-            ParsedBusinessKnowledgeModelFailure(reference.id, reference.namespace, ExpressionFailure(failure.message))
-          }
+        .getOrElse {
+          val failure = Failure(s"No import found for namespace '${reference.namespace}'.")
+          ctx.failures += failure
+          ParsedBusinessKnowledgeModelFailure(reference.id, reference.namespace, ExpressionFailure(failure.message))
+        }
     }
   }
 
@@ -560,27 +561,25 @@ class DmnParser(
     ctx: ParsingContext): ParsedDecisionLogic = {
 
     val bindings = invocation.getBindings.asScala
-      .map(b =>
+      .flatMap(b =>
         b.getExpression match {
           case lt: LiteralExpression =>
             Some(b.getParameter.getName -> parseFeelExpression(lt))
           case other => {
             ctx.failures += Failure(
               s"expected binding with literal expression but found '$other'")
-
             None
           }
         })
-      .flatten
 
     invocation.getExpression match {
       case lt: LiteralExpression => {
         val expression = lt.getText.getTextContent
 
         ctx.bkms
           .get(expression)
-          .map(bkm => {
-            ParsedInvocation(bindings, bkm.resolve())
+          .map(bkmRef => {
+            ParsedInvocation(bindings, bkmRef.resolve())
           })
           .getOrElse {
             ctx.failures += Failure(s"no BKM found with name '$expression'")
@@ -635,8 +634,7 @@ class DmnParser(
       .map(_.getTextContent)
       .toRight(Failure(s"The expression '${lt.getId}' must not be empty."))
 
-  private def validateExpressionLanguage(
-    lt: LiteralExpression): Either[Failure, Unit] = {
+  private def validateExpressionLanguage(lt: LiteralExpression): Either[Failure, Unit] = {
     val language =
       Option(lt.getExpressionLanguage).map(_.toLowerCase).getOrElse("feel")
     if (feelNameSpaces.contains(language)) {

src/main/scala/org/camunda/dmn/parser/ParsedDmn.scala

@@ -51,7 +51,7 @@ sealed trait ParsedDecisionLogicContainer {
   val logic: ParsedDecisionLogic
 }
 
-sealed trait ParsedDecision extends ParsedDecisionLogicContainer{
+trait ParsedDecision extends ParsedDecisionLogicContainer {
   val resultName: String
   val resultType: Option[String]
   val requiredDecisions: Iterable[ParsedDecisionReference]
@@ -76,8 +76,7 @@ case class EmbeddedDecision(
   resultType: Option[String],
   requiredDecisions: Iterable[ParsedDecisionReference],
   requiredBkms: Iterable[ParsedBusinessKnowledgeModelReference]
-)
-  extends ParsedDecision with ParsedDecisionReference {
+) extends ParsedDecision with ParsedDecisionReference {
   override def resolve(): ParsedDecision = this
 
   override def isEmbedded: Boolean = true
@@ -112,20 +111,22 @@ trait ParsedBusinessKnowledgeModelReference extends ParsedDecisionLogicContainer
 
 
 case class EmbeddedBusinessKnowledgeModel(
-                                         id: String,
-                                         name: String,
-                                         logic: ParsedDecisionLogic,
-                                         parameters: Iterable[(String, String)],
-                                         requiredBkms: Iterable[ParsedBusinessKnowledgeModelReference])
-  extends ParsedBusinessKnowledgeModel with ParsedBusinessKnowledgeModelReference {
+  id: String,
+  name: String,
+  logic: ParsedDecisionLogic,
+  parameters: Iterable[(String, String)],
+  requiredBkms: Iterable[ParsedBusinessKnowledgeModelReference]) extends
+ParsedBusinessKnowledgeModel with ParsedBusinessKnowledgeModelReference {
+
   override def resolve(): ParsedBusinessKnowledgeModel = this
 
   override def isEmbedded: Boolean = true
 }
 
 case class ImportedBusinessKnowledgeModel(
-  repository: DmnRepository, namespace: String, id: String, override val importedModelName: Option[String])
-  extends ParsedBusinessKnowledgeModelReference {
+  repository: DmnRepository,
+  namespace: String, id: String,
+  override val importedModelName: Option[String]) extends ParsedBusinessKnowledgeModelReference {
   override def resolve(): ParsedBusinessKnowledgeModel = repository.getBusinessKnowledgeModel(namespace, id) match {
     case Right(found) => found
     case Left(failure) =>