config_scheme.json

{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "title": "ConfigurationFile",
  "description": "Represents a whole configuration file consisting of several comparison rules",
  "type": "object",
  "required": [
    "rules"
  ],
  "properties": {
    "rules": {
      "description": "A list of all rules to be checked on run",
      "type": "array",
      "items": {
        "$ref": "#/definitions/Rule"
      }
    }
  },
  "definitions": {
    "CSVCompareConfig": {
      "description": "Settings for the CSV comparison module",
      "type": "object",
      "required": [
        "comparison_modes"
      ],
      "properties": {
        "comparison_modes": {
          "description": "How numerical values shall be compared, strings are always checked for identity",
          "type": "array",
          "items": {
            "$ref": "#/definitions/Mode"
          }
        },
        "decimal_separator": {
          "description": "The decimal separator for floating point numbers (typically dot or comma)",
          "type": [
            "string",
            "null"
          ],
          "maxLength": 1,
          "minLength": 1
        },
        "exclude_field_regex": {
          "description": "Any field matching the given regex is excluded from comparison",
          "type": [
            "string",
            "null"
          ]
        },
        "field_delimiter": {
          "description": "The delimiters of the csv fields (typically comma, semicolon or pipe)",
          "type": [
            "string",
            "null"
          ],
          "maxLength": 1,
          "minLength": 1
        },
        "preprocessing": {
          "description": "Preprocessing done to the csv files before beginning the comparison",
          "type": [
            "array",
            "null"
          ],
          "items": {
            "$ref": "#/definitions/Preprocessor"
          }
        }
      }
    },
    "ExternalConfig": {
      "type": "object",
      "required": [
        "executable",
        "extra_params"
      ],
      "properties": {
        "executable": {
          "description": "The executable to call - will be started like: `#executable #(#extra_params)* #nominal #actual`",
          "type": "string"
        },
        "extra_params": {
          "description": "Extra parameters to pass",
          "type": "array",
          "items": {
            "type": "string"
          }
        }
      }
    },
    "GrayCompareMode": {
      "oneOf": [
        {
          "type": "object",
          "required": [
            "Structure"
          ],
          "properties": {
            "Structure": {
              "$ref": "#/definitions/GrayStructureAlgorithm"
            }
          },
          "additionalProperties": false
        },
        {
          "type": "object",
          "required": [
            "Histogram"
          ],
          "properties": {
            "Histogram": {
              "$ref": "#/definitions/GrayHistogramCompareMetric"
            }
          },
          "additionalProperties": false
        }
      ]
    },
    "GrayHistogramCompareMetric": {
      "type": "string",
      "enum": [
        "Correlation",
        "ChiSquare",
        "Intersection",
        "Hellinger"
      ]
    },
    "GrayStructureAlgorithm": {
      "type": "string",
      "enum": [
        "MSSIM",
        "RMS"
      ]
    },
    "HTMLCompareConfig": {
      "description": "Plain text comparison config, also used for PDF",
      "type": "object",
      "required": [
        "threshold"
      ],
      "properties": {
        "ignore_lines": {
          "description": "Lines matching any of the given regex will be excluded from comparison",
          "type": [
            "array",
            "null"
          ],
          "items": {
            "type": "string"
          }
        },
        "threshold": {
          "description": "Normalized Damerau-Levenshtein distance, 0.0 = bad, 1.0 = identity",
          "type": "number",
          "format": "double"
        }
      }
    },
    "HashConfig": {
      "description": "Configuration options for the hash comparison module",
      "type": "object",
      "required": [
        "function"
      ],
      "properties": {
        "function": {
          "description": "Which hash function to use",
          "allOf": [
            {
              "$ref": "#/definitions/HashFunction"
            }
          ]
        }
      }
    },
    "HashFunction": {
      "type": "string",
      "enum": [
        "Sha256"
      ]
    },
    "ImageCompareConfig": {
      "description": "Image comparison config options",
      "type": "object",
      "oneOf": [
        {
          "type": "object",
          "required": [
            "RGB"
          ],
          "properties": {
            "RGB": {
              "$ref": "#/definitions/RGBCompareMode"
            }
          },
          "additionalProperties": false
        },
        {
          "type": "object",
          "required": [
            "RGBA"
          ],
          "properties": {
            "RGBA": {
              "$ref": "#/definitions/RGBACompareMode"
            }
          },
          "additionalProperties": false
        },
        {
          "type": "object",
          "required": [
            "Gray"
          ],
          "properties": {
            "Gray": {
              "$ref": "#/definitions/GrayCompareMode"
            }
          },
          "additionalProperties": false
        }
      ],
      "required": [
        "threshold"
      ],
      "properties": {
        "threshold": {
          "description": "Threshold for image comparison < 0.5 is very dissimilar, 1.0 is identical",
          "type": "number",
          "format": "double"
        }
      }
    },
    "JsonConfig": {
      "description": "configuration for the json compare module",
      "type": "object",
      "properties": {
        "ignore_keys": {
          "default": [],
          "type": "array",
          "items": {
            "type": "string"
          }
        },
        "sort_arrays": {
          "default": false,
          "type": "boolean"
        }
      }
    },
    "Mode": {
      "description": "comparison mode for csv cells",
      "oneOf": [
        {
          "description": "`(a-b).abs() < threshold`",
          "type": "object",
          "required": [
            "Absolute"
          ],
          "properties": {
            "Absolute": {
              "type": "number",
              "format": "double"
            }
          },
          "additionalProperties": false
        },
        {
          "description": "`((a-b)/a).abs() < threshold`",
          "type": "object",
          "required": [
            "Relative"
          ],
          "properties": {
            "Relative": {
              "type": "number",
              "format": "double"
            }
          },
          "additionalProperties": false
        },
        {
          "description": "always matches",
          "type": "string",
          "enum": [
            "Ignore"
          ]
        }
      ]
    },
    "Preprocessor": {
      "description": "Preprocessor options",
      "oneOf": [
        {
          "description": "Try to extract the headers from the first row - fallible if first row contains a number",
          "type": "string",
          "enum": [
            "ExtractHeaders"
          ]
        },
        {
          "description": "Replace all fields in column by number by a deleted marker",
          "type": "object",
          "required": [
            "DeleteColumnByNumber"
          ],
          "properties": {
            "DeleteColumnByNumber": {
              "type": "integer",
              "format": "uint",
              "minimum": 0.0
            }
          },
          "additionalProperties": false
        },
        {
          "description": "Replace all fields in column by name by a deleted marker",
          "type": "object",
          "required": [
            "DeleteColumnByName"
          ],
          "properties": {
            "DeleteColumnByName": {
              "type": "string"
            }
          },
          "additionalProperties": false
        },
        {
          "description": "Sort rows by column with given name. Fails if no headers were extracted or column name is not found, or if any row has no numbers there",
          "type": "object",
          "required": [
            "SortByColumnName"
          ],
          "properties": {
            "SortByColumnName": {
              "type": "string"
            }
          },
          "additionalProperties": false
        },
        {
          "description": "Sort rows by column with given number. Fails if any row has no numbers there or if out of bounds.",
          "type": "object",
          "required": [
            "SortByColumnNumber"
          ],
          "properties": {
            "SortByColumnNumber": {
              "type": "integer",
              "format": "uint",
              "minimum": 0.0
            }
          },
          "additionalProperties": false
        },
        {
          "description": "Replace all fields in row with given number by a deleted marker",
          "type": "object",
          "required": [
            "DeleteRowByNumber"
          ],
          "properties": {
            "DeleteRowByNumber": {
              "type": "integer",
              "format": "uint",
              "minimum": 0.0
            }
          },
          "additionalProperties": false
        },
        {
          "description": "Replace all fields in row  where at least a single field matches regex by a deleted marker",
          "type": "object",
          "required": [
            "DeleteRowByRegex"
          ],
          "properties": {
            "DeleteRowByRegex": {
              "type": "string"
            }
          },
          "additionalProperties": false
        },
        {
          "description": "replace found cell using row and column index by a deleted marker",
          "type": "object",
          "required": [
            "DeleteCellByNumber"
          ],
          "properties": {
            "DeleteCellByNumber": {
              "type": "object",
              "required": [
                "column",
                "row"
              ],
              "properties": {
                "column": {
                  "description": "column number",
                  "type": "integer",
                  "format": "uint",
                  "minimum": 0.0
                },
                "row": {
                  "description": "row number",
                  "type": "integer",
                  "format": "uint",
                  "minimum": 0.0
                }
              }
            }
          },
          "additionalProperties": false
        },
        {
          "description": "replace found cell using column header and row index by a deleted marker",
          "type": "object",
          "required": [
            "DeleteCellByName"
          ],
          "properties": {
            "DeleteCellByName": {
              "type": "object",
              "required": [
                "column",
                "row"
              ],
              "properties": {
                "column": {
                  "description": "column with given name",
                  "type": "string"
                },
                "row": {
                  "description": "row number",
                  "type": "integer",
                  "format": "uint",
                  "minimum": 0.0
                }
              }
            }
          },
          "additionalProperties": false
        }
      ]
    },
    "PropertiesConfig": {
      "description": "the configuration struct for file property comparison",
      "type": "object",
      "properties": {
        "file_size_tolerance_bytes": {
          "description": "Compare the file size, difference must be smaller then given value",
          "type": [
            "integer",
            "null"
          ],
          "format": "uint64",
          "minimum": 0.0
        },
        "forbid_name_regex": {
          "description": "Fail if the name contains that regex",
          "type": [
            "string",
            "null"
          ]
        },
        "modification_date_tolerance_secs": {
          "description": "Compare the modification date, difference must be smaller then the given value",
          "type": [
            "integer",
            "null"
          ],
          "format": "uint64",
          "minimum": 0.0
        }
      }
    },
    "RGBACompareMode": {
      "oneOf": [
        {
          "description": "full RGBA comparison - probably not intuitive, rarely what you want outside of video processing Will do MSSIM on luma, then RMS on U and V and alpha channels. The calculation of the score is then pixel-wise the minimum of each pixels similarity. To account for perceived indifference in lower alpha regions, this down-weights the difference linearly with mean alpha channel.",
          "type": "string",
          "enum": [
            "Hybrid"
          ]
        },
        {
          "description": "pre-blend the background in RGBA with this color, use the background RGB values you would assume the pictures to be seen on - usually either black or white",
          "type": "object",
          "required": [
            "HybridBlended"
          ],
          "properties": {
            "HybridBlended": {
              "type": "object",
              "required": [
                "b",
                "g",
                "r"
              ],
              "properties": {
                "b": {
                  "type": "integer",
                  "format": "uint8",
                  "minimum": 0.0
                },
                "g": {
                  "type": "integer",
                  "format": "uint8",
                  "minimum": 0.0
                },
                "r": {
                  "type": "integer",
                  "format": "uint8",
                  "minimum": 0.0
                }
              }
            }
          },
          "additionalProperties": false
        }
      ]
    },
    "RGBCompareMode": {
      "oneOf": [
        {
          "description": "Comparing rgb images using structure. RGB structure similarity is performed by doing a channel split and taking the maximum deviation (minimum similarity) for the result. The image contains the complete deviations. Algorithm: RMS",
          "type": "string",
          "enum": [
            "RMS"
          ]
        },
        {
          "description": "Comparing rgb images using structure. RGB structure similarity is performed by doing a channel split and taking the maximum deviation (minimum similarity) for the result. The image contains the complete deviations. Algorithm: MSSIM",
          "type": "string",
          "enum": [
            "MSSIM"
          ]
        },
        {
          "description": "Comparing structure via MSSIM on Y channel, comparing color-diff-vectors on U and V summing the squares Please mind that the RGBSimilarity-Image does not contain plain RGB here. Probably what you want.",
          "type": "string",
          "enum": [
            "Hybrid"
          ]
        }
      ]
    },
    "Rule": {
      "description": "Representing a single comparison rule",
      "type": "object",
      "oneOf": [
        {
          "description": "smart CSV compare",
          "type": "object",
          "required": [
            "CSV"
          ],
          "properties": {
            "CSV": {
              "$ref": "#/definitions/CSVCompareConfig"
            }
          },
          "additionalProperties": false
        },
        {
          "description": "thresholds comparison",
          "type": "object",
          "required": [
            "Image"
          ],
          "properties": {
            "Image": {
              "$ref": "#/definitions/ImageCompareConfig"
            }
          },
          "additionalProperties": false
        },
        {
          "description": "plain text compare",
          "type": "object",
          "required": [
            "PlainText"
          ],
          "properties": {
            "PlainText": {
              "$ref": "#/definitions/HTMLCompareConfig"
            }
          },
          "additionalProperties": false
        },
        {
          "description": "Compare using file hashes",
          "type": "object",
          "required": [
            "Hash"
          ],
          "properties": {
            "Hash": {
              "$ref": "#/definitions/HashConfig"
            }
          },
          "additionalProperties": false
        },
        {
          "description": "PDF text compare",
          "type": "object",
          "required": [
            "PDFText"
          ],
          "properties": {
            "PDFText": {
              "$ref": "#/definitions/HTMLCompareConfig"
            }
          },
          "additionalProperties": false
        },
        {
          "description": "Compare file-properties",
          "type": "object",
          "required": [
            "FileProperties"
          ],
          "properties": {
            "FileProperties": {
              "$ref": "#/definitions/PropertiesConfig"
            }
          },
          "additionalProperties": false
        },
        {
          "description": "Compare JSON files",
          "type": "object",
          "required": [
            "Json"
          ],
          "properties": {
            "Json": {
              "$ref": "#/definitions/JsonConfig"
            }
          },
          "additionalProperties": false
        },
        {
          "description": "Run external comparison executable",
          "type": "object",
          "required": [
            "External"
          ],
          "properties": {
            "External": {
              "$ref": "#/definitions/ExternalConfig"
            }
          },
          "additionalProperties": false
        }
      ],
      "required": [
        "name",
        "pattern_include"
      ],
      "properties": {
        "name": {
          "description": "The name of the rule - will be displayed in logs",
          "type": "string"
        },
        "pattern_exclude": {
          "description": "A list of glob-patterns to exclude - optional",
          "type": [
            "array",
            "null"
          ],
          "items": {
            "type": "string"
          }
        },
        "pattern_include": {
          "description": "A list of glob-patterns to include",
          "type": "array",
          "items": {
            "type": "string"
          }
        }
      }
    }
  }
}