Merge pull request #115 from valydia/bugfix_notempty

Bugfix notempty

Author: LauraDamianTNA

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

@@ -55,7 +55,9 @@ trait AllErrorsMetaDataValidator extends MetaDataValidator {
     def isOptionDirective: Boolean = columnDefinition.directives.contains(Optional())
 
     if(row.cells(columnIndex).value.trim.isEmpty && isOptionDirective) true.successNel
-    else columnDefinition.rules.map(_.evaluate(columnIndex, row, schema, mayBeLast)).map{ ruleResult:Rule#RuleValidation[Any] => {
+    else columnDefinition.rules.map{rule =>
+      rule.evaluate(columnIndex, row, schema, mayBeLast)
+    }.map{ ruleResult:Rule#RuleValidation[Any] => {
       if(isWarningDirective) toWarnings(ruleResult, row.lineNumber, columnIndex) else toErrors(ruleResult, row.lineNumber, columnIndex)
     }}.sequence[MetaDataValidation, Any]
   }

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_0/SchemaValidator.scala

@@ -219,19 +219,16 @@ class SchemaValidator {
 
  protected def explicitColumnValid(columnDefinitions: List[ColumnDefinition]): Option[String] = {
 
-   def invalidColumnNames(rule: Rule) = explicitColumnCheck(rule) match {
-     case Some(x) => x
-     case None => List.empty[ColumnIdentifier]
-   }
-
-   def checkAlternativeOption(rules: Option[List[Rule]]): Option[List[ColumnIdentifier]] = rules match {
-     case Some(rulesList) => Some(rulesList.foldLeft(List.empty[ColumnIdentifier]) {
-       case (list, rule: Rule) => list ++ invalidColumnNames(rule)
-     })
+   def invalidColumnNames(rule: Rule) = explicitColumnCheck(rule).getOrElse(List.empty[ColumnIdentifier])
 
-     case None => None
+   def checkAlternativeOption(rules: Option[List[Rule]]): Option[List[ColumnIdentifier]] = {
+     rules.map{ _.foldLeft(List.empty[ColumnIdentifier]) {
+         case (list, rule: Rule) => list ++ invalidColumnNames(rule)
+       }
+     }
    }
 
+
    def explicitColumnCheck(rule: Rule): Option[List[ColumnIdentifier]] = rule match {
      case IfRule(c, t, f) =>
        val cond = explicitColumnCheck(c)

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
   }
 

csv-validator-core/src/test/resources/uk/gov/nationalarchives/csv/validator/acceptance/notempty.csv

@@ -0,0 +1,5 @@
+c1,c2,c3,c4
+aaa,cell1-2,bbb,cell1-4
+cell2-1,,bbb,cell2-4
+cell3-1,,cell3-3,
+aaa,cell4-2,cell4-3,

csv-validator-core/src/test/resources/uk/gov/nationalarchives/csv/validator/acceptance/notempty.csvs

@@ -0,0 +1,6 @@
+version 1.0
+@totalColumns 4
+c1: if($c2/notEmpty, is("aaa"))
+c2: 
+c3: if($c4/notEmpty, is("bbb"))
+c4: