#1650

Committed 06 May 2026 09:15PM UTC coverage: 90.187% (-0.02%) from 90.202%

Build # #1650

Build Type

push

Committed by

Commit Message

Reporting deprecated terms in MARC vocabularies #764: use in validation

Coverage Stats

20 of 22 new or added lines in 3 files covered. (90.91%)

6 existing lines in 1 file now uncovered.

36754 of 40753 relevant lines covered (90.19%)

0.9 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

88.51

/src/main/java/de/gwdg/metadataqa/marc/analysis/validator/SubfieldValidator.java

package de.gwdg.metadataqa.marc.analysis.validator;

import de.gwdg.metadataqa.marc.MarcSubfield;
import de.gwdg.metadataqa.marc.definition.ValidatorResponse;
import de.gwdg.metadataqa.marc.definition.general.parser.ParserException;
import de.gwdg.metadataqa.marc.definition.general.parser.SubfieldContentParser;
import de.gwdg.metadataqa.marc.definition.structure.ControlfieldPositionDefinition;
import de.gwdg.metadataqa.marc.definition.structure.DataFieldDefinition;
import de.gwdg.metadataqa.marc.definition.structure.SubfieldDefinition;
import de.gwdg.metadataqa.marc.model.validation.ErrorsCollector;
import de.gwdg.metadataqa.marc.model.validation.ValidationErrorType;

import java.util.ArrayList;

import static de.gwdg.metadataqa.marc.model.validation.ValidationErrorType.SUBFIELD_NULL_CODE;
import static de.gwdg.metadataqa.marc.model.validation.ValidationErrorType.SUBFIELD_UNDEFINED;
import static de.gwdg.metadataqa.marc.model.validation.ValidationErrorType.SUBFIELD_UNPARSABLE_CONTENT;

public class SubfieldValidator extends AbstractValidator {

  private ErrorsCollector errors;
  private SubfieldDefinition definition;
  private DataFieldDefinition fieldDefinition;
  private MarcSubfield subfield;

  public SubfieldValidator() {
    super(new ValidatorConfiguration());
  }

  public SubfieldValidator(ValidatorConfiguration configuration) {
    super(configuration);
  }

  public boolean validate(MarcSubfield subfield) {
    this.subfield = subfield;

    errors = new ErrorsCollector();
    validationErrors = new ArrayList<>();
    definition = subfield.getDefinition();
    fieldDefinition = subfield.getField().getDefinition();

    if (definition == null) {
      addError(fieldDefinition.getExtendedTag(), SUBFIELD_UNDEFINED, subfield.getCode());
      validationErrors.addAll(errors.getErrors());
      return false;
    }

    if (subfield.getCode() == null) {
      addError(subfield.getField().getDefinition().getTag(), SUBFIELD_NULL_CODE, subfield.getCode());
      validationErrors.addAll(errors.getErrors());
      return false;
    }

    if (definition.isDisallowedIn(configuration.getMarcVersion())) {
      addError(subfield.getField().getDefinition().getTag(), SUBFIELD_UNDEFINED, subfield.getCode());
      validationErrors.addAll(errors.getErrors());
      return false;
    }

    if (definition.hasValidator()) {
      validateWithValidator();
    } else if (definition.hasContentParser()) {
      validateWithParser();
    } else if (definition.getCodes() != null
               && !definition.getCodes().isEmpty()
               && definition.getCode(subfield.getValue()) == null) {
      // If a subfield has a list of codes defined, and the value is not in the codelist, then it is invalid
      createCodeError(subfield, ValidationErrorType.SUBFIELD_INVALID_VALUE);
    } else if (definition.getCodeList() != null) {
      if (!definition.getCodeList().isValid(subfield.getValue())) {
        createCodeError(subfield, ValidationErrorType.SUBFIELD_INVALID_VALUE);
      }
      if (definition.getCodeList().isDeprecated(subfield.getValue())) {
        createCodeError(subfield, ValidationErrorType.SUBFIELD_DEPRECATED_VALUE);
      }
      // isValid = false;
      /**/
    } else if (definition.hasPositions()) {
      validatePositions();
    }

    validationErrors.addAll(errors.getErrors());
    return errors.isEmpty();
  }

  private void createCodeError(MarcSubfield subfield, ValidationErrorType errorType) {
    String message = subfield.getValue();
    String referencePath = subfield.getReferencePath();
    if (referencePath != null) {
      message += String.format(" (the field is embedded in %s)", referencePath);
    }
    String path = (referencePath == null
      ? definition.getPath()
      : referencePath + "->" + definition.getPath());
    addError(path, errorType, message);
  }

  private void validatePositions() {
    for (ControlfieldPositionDefinition positionDefinition : definition.getPositions()) {
      validatePosition(positionDefinition);
    }
  }

  private void validatePosition(ControlfieldPositionDefinition positionDefinition) {
    String subfieldValue = subfield.getValue();
    // If the subfield value is shorter than the position definition, then it is invalid
    if (subfieldValue.length() < positionDefinition.getPositionEnd()) {
      String path = String.format("%s/%s", definition.getPath(), positionDefinition.formatPositon());
      String errorMessage = String.format("invalid code for '%s': '%s' position %s out of range",
          positionDefinition.getLabel(), subfieldValue, positionDefinition.formatPositon());

      addError(path, ValidationErrorType.SUBFIELD_INVALID_VALUE, errorMessage);
      return;
    }
    String positionValue = subfield.getValue().substring(positionDefinition.getPositionStart(), positionDefinition.getPositionEnd());
    boolean isPositionDefinitionValid = positionDefinition.validate(positionValue);
    if (isPositionDefinitionValid) {
      return;
    }

    String path = String.format("%s/%s", definition.getPath(), positionDefinition.formatPositon());
    String errorMessage = String.format("invalid code for '%s': '%s' at position %s in '%s'",
        positionDefinition.getLabel(), positionValue, positionDefinition.formatPositon(), subfield.getValue());

    addError(path, ValidationErrorType.SUBFIELD_INVALID_VALUE, errorMessage);
  }

  /**
   * Validates a subfield by the given subfield validator which is assigned to the subfield definition in code.
   * @return True if the subfield is valid, false otherwise.
   */
  private boolean validateWithValidator() {
    de.gwdg.metadataqa.marc.definition.general.validator.SubfieldValidator validator = definition.getValidator();
    ValidatorResponse response = validator.isValid(subfield);
    if (!response.isValid()) {
      errors.addAll(response.getValidationErrors());
    }
    return response.isValid();
  }

  /**
   * Uses a similar approach as the subfield validator in the subfield definition trying to parse the subfield content.
   * @return True if the subfield is valid, false otherwise.
   */
  private boolean validateWithParser() {
    var isValid = true;
    SubfieldContentParser parser = definition.getContentParser();
    try {
      parser.parse(subfield.getValue());
    } catch (ParserException e) {
      addError(SUBFIELD_UNPARSABLE_CONTENT, e.getMessage());
      isValid = false;
    }
    return isValid;
  }

  private void addError(ValidationErrorType type, String message) {
    addError(definition.getPath(), type, message);
  }

  private void addError(String path, ValidationErrorType type, String message) {
    if (!isIgnorableType(type)) {
      String id = subfield.getMarcRecord() == null ? null : subfield.getMarcRecord().getId();
      String url = fieldDefinition.getDescriptionUrl();
      errors.add(id, path, type, message, url);
    }
  }
}

1	package de.gwdg.metadataqa.marc.analysis.validator;
2
3	import de.gwdg.metadataqa.marc.MarcSubfield;
4	import de.gwdg.metadataqa.marc.definition.ValidatorResponse;
5	import de.gwdg.metadataqa.marc.definition.general.parser.ParserException;
6	import de.gwdg.metadataqa.marc.definition.general.parser.SubfieldContentParser;
7	import de.gwdg.metadataqa.marc.definition.structure.ControlfieldPositionDefinition;
8	import de.gwdg.metadataqa.marc.definition.structure.DataFieldDefinition;
9	import de.gwdg.metadataqa.marc.definition.structure.SubfieldDefinition;
10	import de.gwdg.metadataqa.marc.model.validation.ErrorsCollector;
11	import de.gwdg.metadataqa.marc.model.validation.ValidationErrorType;
12
13	import java.util.ArrayList;
14
15	import static de.gwdg.metadataqa.marc.model.validation.ValidationErrorType.SUBFIELD_NULL_CODE;
16	import static de.gwdg.metadataqa.marc.model.validation.ValidationErrorType.SUBFIELD_UNDEFINED;
17	import static de.gwdg.metadataqa.marc.model.validation.ValidationErrorType.SUBFIELD_UNPARSABLE_CONTENT;
18
19	public class SubfieldValidator extends AbstractValidator {
20
21	private ErrorsCollector errors;
22	private SubfieldDefinition definition;
23	private DataFieldDefinition fieldDefinition;
24	private MarcSubfield subfield;
25
26	public SubfieldValidator() {
27	super(new ValidatorConfiguration());	1✔
28	}	1✔
29
30	public SubfieldValidator(ValidatorConfiguration configuration) {
31	super(configuration);	1✔
32	}	1✔
33
34	public boolean validate(MarcSubfield subfield) {
35	this.subfield = subfield;	1✔
36
37	errors = new ErrorsCollector();	1✔
38	validationErrors = new ArrayList<>();	1✔
39	definition = subfield.getDefinition();	1✔
40	fieldDefinition = subfield.getField().getDefinition();	1✔
41
42	if (definition == null) {	1✔
43	addError(fieldDefinition.getExtendedTag(), SUBFIELD_UNDEFINED, subfield.getCode());	1✔
44	validationErrors.addAll(errors.getErrors());	1✔
45	return false;	1✔
46	}
47
48	if (subfield.getCode() == null) {	1✔
49	addError(subfield.getField().getDefinition().getTag(), SUBFIELD_NULL_CODE, subfield.getCode());	×
50	validationErrors.addAll(errors.getErrors());	×
51	return false;	×
52	}
53
54	if (definition.isDisallowedIn(configuration.getMarcVersion())) {	1✔
55	addError(subfield.getField().getDefinition().getTag(), SUBFIELD_UNDEFINED, subfield.getCode());	1✔
56	validationErrors.addAll(errors.getErrors());	1✔
57	return false;	1✔
58	}
59
60	if (definition.hasValidator()) {	1✔
61	validateWithValidator();	1✔
62	} else if (definition.hasContentParser()) {	1✔
63	validateWithParser();	1✔
64	} else if (definition.getCodes() != null	1✔
65	&& !definition.getCodes().isEmpty()	1✔
66	&& definition.getCode(subfield.getValue()) == null) {	1✔
67	// If a subfield has a list of codes defined, and the value is not in the codelist, then it is invalid
68	createCodeError(subfield, ValidationErrorType.SUBFIELD_INVALID_VALUE);	1✔
69	} else if (definition.getCodeList() != null) {	1✔
70	if (!definition.getCodeList().isValid(subfield.getValue())) {	1✔
71	createCodeError(subfield, ValidationErrorType.SUBFIELD_INVALID_VALUE);	1✔
72	}
73	if (definition.getCodeList().isDeprecated(subfield.getValue())) {	1✔
NEW 74	createCodeError(subfield, ValidationErrorType.SUBFIELD_DEPRECATED_VALUE);	×
75	}
76	// isValid = false;
77	/**/
78	} else if (definition.hasPositions()) {	1✔
79	validatePositions();	1✔
80	}
81
82	validationErrors.addAll(errors.getErrors());	1✔
83	return errors.isEmpty();	1✔
84	}
85
86	private void createCodeError(MarcSubfield subfield, ValidationErrorType errorType) {
87	String message = subfield.getValue();	1✔
88	String referencePath = subfield.getReferencePath();	1✔
89	if (referencePath != null) {	1✔
NEW 90	message += String.format(" (the field is embedded in %s)", referencePath);	×
91	}
92	String path = (referencePath == null	1✔
93	? definition.getPath()	1✔
94	: referencePath + "->" + definition.getPath());	1✔
95	addError(path, errorType, message);	1✔
96	}	1✔
97
98	private void validatePositions() {
99	for (ControlfieldPositionDefinition positionDefinition : definition.getPositions()) {	1✔
100	validatePosition(positionDefinition);	1✔
101	}	1✔
102	}	1✔
103
104	private void validatePosition(ControlfieldPositionDefinition positionDefinition) {
105	String subfieldValue = subfield.getValue();	1✔
106	// If the subfield value is shorter than the position definition, then it is invalid
107	if (subfieldValue.length() < positionDefinition.getPositionEnd()) {	1✔
108	String path = String.format("%s/%s", definition.getPath(), positionDefinition.formatPositon());	×
109	String errorMessage = String.format("invalid code for '%s': '%s' position %s out of range",	×
110	positionDefinition.getLabel(), subfieldValue, positionDefinition.formatPositon());	×
111
112	addError(path, ValidationErrorType.SUBFIELD_INVALID_VALUE, errorMessage);	×
113	return;	×
114	}
115	String positionValue = subfield.getValue().substring(positionDefinition.getPositionStart(), positionDefinition.getPositionEnd());	1✔
116	boolean isPositionDefinitionValid = positionDefinition.validate(positionValue);	1✔
117	if (isPositionDefinitionValid) {	1✔
118	return;	1✔
119	}
120
121	String path = String.format("%s/%s", definition.getPath(), positionDefinition.formatPositon());	1✔
122	String errorMessage = String.format("invalid code for '%s': '%s' at position %s in '%s'",	1✔
123	positionDefinition.getLabel(), positionValue, positionDefinition.formatPositon(), subfield.getValue());	1✔
124
125	addError(path, ValidationErrorType.SUBFIELD_INVALID_VALUE, errorMessage);	1✔
126	}	1✔
127
128	/**
129	* Validates a subfield by the given subfield validator which is assigned to the subfield definition in code.
130	* @return True if the subfield is valid, false otherwise.
131	*/
132	private boolean validateWithValidator() {
133	de.gwdg.metadataqa.marc.definition.general.validator.SubfieldValidator validator = definition.getValidator();	1✔
134	ValidatorResponse response = validator.isValid(subfield);	1✔
135	if (!response.isValid()) {	1✔
136	errors.addAll(response.getValidationErrors());	1✔
137	}
138	return response.isValid();	1✔
139	}
140
141	/**
142	* Uses a similar approach as the subfield validator in the subfield definition trying to parse the subfield content.
143	* @return True if the subfield is valid, false otherwise.
144	*/
145	private boolean validateWithParser() {
146	var isValid = true;	1✔
147	SubfieldContentParser parser = definition.getContentParser();	1✔
148	try {
149	parser.parse(subfield.getValue());	1✔
150	} catch (ParserException e) {	1✔
151	addError(SUBFIELD_UNPARSABLE_CONTENT, e.getMessage());	1✔
152	isValid = false;	1✔
153	}	1✔
154	return isValid;	1✔
155	}
156
157	private void addError(ValidationErrorType type, String message) {
158	addError(definition.getPath(), type, message);	1✔
159	}	1✔
160
161	private void addError(String path, ValidationErrorType type, String message) {
162	if (!isIgnorableType(type)) {	1✔
163	String id = subfield.getMarcRecord() == null ? null : subfield.getMarcRecord().getId();	1✔
164	String url = fieldDefinition.getDescriptionUrl();	1✔
165	errors.add(id, path, type, message, url);	1✔
166	}
167	}	1✔
168	}

pkiraly / metadata-qa-marc / #1650

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous