Fixed bug with several not empty

Author: valydia

csv-validator-core/src/main/scala/uk/gov/nationalarchives/csv/validator/schema/Rule.scala

@@ -11,6 +11,7 @@ package uk.gov.nationalarchives.csv.validator.schema
 import org.joda.time.DateTime
 import uk.gov.nationalarchives.csv.validator.metadata.Row
 
+import scala.collection.mutable.MutableList
 import scala.util.Try
 import scala.util.parsing.input.Positional
 import scalaz._
@@ -22,10 +23,37 @@ abstract class Rule(name: String, val argProviders: ArgProvider*) extends Positi
 
   var explicitColumn: Option[ColumnReference] = None
 
+  def findColumnReference(): Option[ColumnReference] = {
+    if (explicitColumns.nonEmpty){
+      val index =  explicitColumnIndex
+      val result = explicitColumns.get(index)
+      if (index + 1 == explicitColumns.length)
+        explicitColumnIndex = 0
+      else
+        explicitColumnIndex = index + 1
+      result
+    }
+    else{
+      explicitColumn = None
+      None
+    }
+  }
+
+
+  def findColumnRefence(rule: Rule): Option[ColumnReference] =
+    rule.findColumnReference()
+
+  var explicitColumnIndex = 0
+
+  val explicitColumns: MutableList[ColumnReference] = MutableList()
+
   def evaluate(columnIndex: Int, row: Row,  schema: Schema, mayBeLast: Option[Boolean] = None): RuleValidation[Any] = {
-    if (valid(cellValue(columnIndex, row, schema), schema.columnDefinitions(columnIndex), columnIndex, row, schema, mayBeLast)) true.successNel[String] else fail(columnIndex, row, schema)
+    if (valid(cellValue(columnIndex, row, schema), schema.columnDefinitions(columnIndex), columnIndex, row, schema, mayBeLast))
+      true.successNel[String]
+    else fail(columnIndex, row, schema)
   }
 
+
   def valid(cellValue: String, columnDefinition: ColumnDefinition, columnIndex: Int,
             row: Row, schema: Schema, mayBeLast: Option[Boolean] = None): Boolean =
     evaluate(columnIndex, row, schema).isSuccess
@@ -36,15 +64,18 @@ abstract class Rule(name: String, val argProviders: ArgProvider*) extends Positi
     s"$toError fails for line: ${row.lineNumber}, column: ${columnDefinition.id}, ${toValueError(row,columnIndex)}".failureNel[Any]
   }
 
-  def cellValue(columnIndex: Int, row: Row, schema: Schema): String = explicitColumn match {
-    case Some(columnRef) =>
-      columnRef.referenceValueEx(columnIndex, row, schema)
-    case None =>
-      row.cells(columnIndex).value
+  def cellValue(columnIndex: Int, row: Row, schema: Schema): String = {
+    explicitColumn match {
+      case Some(columnRef) =>
+        columnRef.referenceValueEx(columnIndex, row, schema)
+      case None =>
+        row.cells(columnIndex).value
+    }
   }
 
   def explicitName: Option[String] = explicitColumn.map("$" + _.ref + "/")
 
+
   def ruleName: String = explicitName.getOrElse("") + name
 
   def columnIdentifierToIndex(schema: Schema, id: ColumnIdentifier): Int = {
@@ -57,9 +88,15 @@ abstract class Rule(name: String, val argProviders: ArgProvider*) extends Positi
     }
   }
 
-  def toValueError(row: Row, columnIndex:Int ) =  s"""value: ${'"'}${row.cells(columnIndex).value}${'"'}"""
 
-  def toError = s"""$ruleName""" + (if (argProviders.isEmpty) "" else "(" + argProviders.foldLeft("")((a, b) => (if (a.isEmpty) "" else a + ", ") + b.toError) + ")")
+
+  def toValueError(row: Row, columnIndex:Int ) =
+    s"""value: ${'"'}${row.cells(columnIndex).value}${'"'}"""
+
+
+  def toError =
+    s"""$ruleName""" + (if (argProviders.isEmpty) "" else "(" + argProviders.foldLeft("")((a, b) => (if (a.isEmpty) "" else a + ", ") + b.toError) + ")")
+
 }
 
 abstract class PatternRule(name: String, pattern: String) extends Rule(name) {

csv-validator-core/src/main/scala/uk/gov/nationalarchives/csv/validator/schema/Schema.scala

@@ -63,11 +63,8 @@ case class ColumnReference(ref: ColumnIdentifier) extends ArgProvider {
 
   @throws[IndexOutOfBoundsException]
   def referenceValueEx(columnIndex: Int, row: Row, schema: Schema): String = {
-    referenceValue(columnIndex, row, schema) match {
-      case Some(rv) =>
-        rv
-      case None =>
-        throw new ArrayIndexOutOfBoundsException(s"Could not access reference column $ref at [$columnIndex:${row.lineNumber}]")
+    referenceValue(columnIndex, row, schema).getOrElse{
+      throw new ArrayIndexOutOfBoundsException(s"Could not access reference column $ref at [$columnIndex:${row.lineNumber}]")
     }
   }
 

csv-validator-core/src/main/scala/uk/gov/nationalarchives/csv/validator/schema/v1_0/Rule.scala

@@ -62,7 +62,7 @@ case class IfRule(condition: Rule, rules: List[Rule], elseRules: Option[List[Rul
   override def evaluate(columnIndex: Int, row: Row, schema: Schema, mayBeLast: Option[Boolean] = None): RuleValidation[Any] = {
 
     def conditionValid: Boolean = {
-      val (cellValue,idx) = condition.explicitColumn match {
+      val (cellValue,idx) = findColumnRefence(condition) match {
         case Some(columnRef) =>
           (columnRef.referenceValueEx(columnIndex, row, schema), columnIdentifierToIndex(schema, columnRef.ref))
         case None =>
@@ -180,7 +180,6 @@ case class NotEmptyRule() extends Rule("notEmpty") {
   }
 }
 
-//case class UriRule() extends PatternRule("uri", UriRegex)
 case class UriRule() extends Rule("uri") {
   override def valid(cellValue: String, columnDefinition: ColumnDefinition, columnIndex: Int, row: Row, schema: Schema, mayBeLast: Option[Boolean] = None): Boolean = {
     try {

csv-validator-core/src/main/scala/uk/gov/nationalarchives/csv/validator/schema/v1_0/SchemaParser.scala

@@ -249,6 +249,7 @@ trait SchemaParser extends BaseSchemaParser {
       positiveIntegerExpr ) ^^ {
       case explicitContext ~ rule =>
         rule.explicitColumn = explicitContext
+        explicitContext.map(rule.explicitColumns += _)
         rule
     }
 
@@ -457,6 +458,7 @@ trait SchemaParser extends BaseSchemaParser {
   lazy val externalSingleExpr: PackratParser[Rule] = "ExternalSingleExpr" ::= opt(explicitContextExpr) ~ (fileExistsExpr | checksumExpr | fileCountExpr) ^^ {
     case explicitContext ~ rule =>
       rule.explicitColumn = explicitContext
+      explicitContext.map(rule.explicitColumns += _)
       rule
   }
 

csv-validator-core/src/main/scala/uk/gov/nationalarchives/csv/validator/schema/v1_1/Rule.scala

@@ -39,7 +39,7 @@ case class SwitchRule(elseRules: Option[List[Rule]], cases:(Rule, List[Rule])*)
 
   override def evaluate(columnIndex: Int, row: Row, schema: Schema, mayBeLast: Option[Boolean] = None): RuleValidation[Any] = {
     def conditionValid(condition: Rule): Boolean = {
-      val (cellValue,idx) = condition.explicitColumn match {
+      val (cellValue,idx) = findColumnRefence(condition) match {
         case Some(columnRef) =>
           (columnRef.referenceValueEx(columnIndex, row, schema), columnIdentifierToIndex(schema, columnRef.ref))
         case None =>

csv-validator-core/src/main/scala/uk/gov/nationalarchives/csv/validator/schema/v1_1/SchemaParser.scala

@@ -54,7 +54,9 @@ trait SchemaParser extends SchemaParser1_0 {
       lowerCaseExpr ) ^^ {
       case explicitContext ~ rule =>
         rule.explicitColumn = explicitContext
+        explicitContext.map(rule.explicitColumns += _)
         rule
+
     }
 
   /**
@@ -70,6 +72,7 @@ trait SchemaParser extends SchemaParser1_0 {
   override lazy val externalSingleExpr: PackratParser[Rule] = "ExternalSingleExpr" ::= opt(explicitContextExpr) ~ (fileExistsExpr | integrityCheckExpr | checksumExpr | fileCountExpr) ^^ {
     case explicitContext ~ rule =>
       rule.explicitColumn = explicitContext
+      explicitContext.map(rule.explicitColumns += _)
       rule
   }