#675

Committed 07 May 2025 05:31PM UTC coverage: 87.233% (-0.01%) from 87.247%

Build # #675

Build Type

push

Committed by

Commit Message

Implement SonarCloud quality suggestions #159

Run Details

0 of 2 new or added lines in 1 file covered. (0.0%)

2 existing lines in 2 files now uncovered.

5521 of 6329 relevant lines covered (87.23%)

0.87 hits per line

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

89.66

/src/main/java/de/gwdg/metadataqa/api/cli/RecordFactory.java

package de.gwdg.metadataqa.api.cli;

import com.opencsv.exceptions.CsvValidationException;
import de.gwdg.metadataqa.api.calculator.CalculatorFacade;
import de.gwdg.metadataqa.api.io.reader.CSVRecordReader;
import de.gwdg.metadataqa.api.io.reader.JSONArrayRecordReader;
import de.gwdg.metadataqa.api.io.reader.JSONRecordReader;
import de.gwdg.metadataqa.api.io.reader.RecordReader;
import de.gwdg.metadataqa.api.io.reader.XMLRecordReader;
import de.gwdg.metadataqa.api.io.writer.CSVJSONResultWriter;
import de.gwdg.metadataqa.api.io.writer.CSVResultWriter;
import de.gwdg.metadataqa.api.io.writer.JSONResultWriter;
import de.gwdg.metadataqa.api.io.writer.ResultWriter;
import de.gwdg.metadataqa.api.schema.Schema;
import org.apache.commons.io.FilenameUtils;

import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.zip.GZIPInputStream;

public class RecordFactory {

  private RecordFactory() {
  }

  public static RecordReader getRecordReader(String inputFile,
                                             CalculatorFacade calculator,
                                             boolean gzip) throws CsvValidationException, IOException {
    return getRecordReader(inputFile, calculator, gzip, null);
  }

  public static RecordReader getRecordReader(String inputFile,
                                             CalculatorFacade calculator,
                                             boolean gzip,
                                             InputFormat inputFormat)
      throws CsvValidationException, IOException {
    final Schema schema = calculator.getSchema();

    BufferedReader inputReader = null;
    if (gzip) {
      FileInputStream fis = new FileInputStream(inputFile);
      GZIPInputStream gis = new GZIPInputStream(fis);
      InputStreamReader inputStreamReader = new InputStreamReader(gis, StandardCharsets.UTF_8);
      inputReader = new BufferedReader(inputStreamReader);
    } else {
      Path inputPath = Paths.get(inputFile);
      inputReader = Files.newBufferedReader(inputPath);
    }

    switch (schema.getFormat()) {
      case JSON:
        if (inputFormat == null || inputFormat.equals(InputFormat.NDJSON))
          return new JSONRecordReader(inputReader, calculator);
        else if (inputFormat.equals(InputFormat.JSON_ARRAY))
          return new JSONArrayRecordReader(inputReader, calculator);
        else
          throw new IllegalArgumentException("Unsupported input format: " + inputFormat);
      case XML:
        return new XMLRecordReader(inputReader, calculator);
      case CSV:
      default:
        return new CSVRecordReader(inputReader, calculator);
    }
  }

  public static ResultWriter getResultWriter(String outputFormat, String outputFile) throws IOException {

    if (outputFormat == null) {
      outputFormat = FilenameUtils.getExtension(outputFile);
    }

    switch (outputFormat) {
      case App.JSON:
      case App.NDJSON:
        return new JSONResultWriter(outputFile);
      case App.CSVJSON:
        return new CSVJSONResultWriter(outputFile);
      case App.CSV:
      default:
        return new CSVResultWriter(outputFile);
    }
  }

  public static ResultWriter getResultWriter(String outputFormat) {
    switch (outputFormat) {
      case App.NDJSON:
        return new JSONResultWriter();
      case App.CSVJSON:
        return new CSVJSONResultWriter();
      case App.CSV:
      default:
        return new CSVResultWriter();
    }
  }
}

1	package de.gwdg.metadataqa.api.cli;
2
3	import com.opencsv.exceptions.CsvValidationException;
4	import de.gwdg.metadataqa.api.calculator.CalculatorFacade;
5	import de.gwdg.metadataqa.api.io.reader.CSVRecordReader;
6	import de.gwdg.metadataqa.api.io.reader.JSONArrayRecordReader;
7	import de.gwdg.metadataqa.api.io.reader.JSONRecordReader;
8	import de.gwdg.metadataqa.api.io.reader.RecordReader;
9	import de.gwdg.metadataqa.api.io.reader.XMLRecordReader;
10	import de.gwdg.metadataqa.api.io.writer.CSVJSONResultWriter;
11	import de.gwdg.metadataqa.api.io.writer.CSVResultWriter;
12	import de.gwdg.metadataqa.api.io.writer.JSONResultWriter;
13	import de.gwdg.metadataqa.api.io.writer.ResultWriter;
14	import de.gwdg.metadataqa.api.schema.Schema;
15	import org.apache.commons.io.FilenameUtils;
16
17	import java.io.BufferedReader;
18	import java.io.FileInputStream;
19	import java.io.IOException;
20	import java.io.InputStreamReader;
21	import java.nio.charset.StandardCharsets;
22	import java.nio.file.Files;
23	import java.nio.file.Path;
24	import java.nio.file.Paths;
25	import java.util.zip.GZIPInputStream;
26
27	public class RecordFactory {
28
29	private RecordFactory() {
30	}
31
32	public static RecordReader getRecordReader(String inputFile,
33	CalculatorFacade calculator,
34	boolean gzip) throws CsvValidationException, IOException {
35	return getRecordReader(inputFile, calculator, gzip, null);	1✔
36	}
37
38	public static RecordReader getRecordReader(String inputFile,
39	CalculatorFacade calculator,
40	boolean gzip,
41	InputFormat inputFormat)
42	throws CsvValidationException, IOException {
43	final Schema schema = calculator.getSchema();	1✔
44
45	BufferedReader inputReader = null;	1✔
46	if (gzip) {	1✔
47	FileInputStream fis = new FileInputStream(inputFile);	1✔
48	GZIPInputStream gis = new GZIPInputStream(fis);	1✔
49	InputStreamReader inputStreamReader = new InputStreamReader(gis, StandardCharsets.UTF_8);	1✔
50	inputReader = new BufferedReader(inputStreamReader);	1✔
51	} else {	1✔
52	Path inputPath = Paths.get(inputFile);	1✔
53	inputReader = Files.newBufferedReader(inputPath);	1✔
54	}
55
56	switch (schema.getFormat()) {	1✔
57	case JSON:
58	if (inputFormat == null \|\| inputFormat.equals(InputFormat.NDJSON))	1✔
59	return new JSONRecordReader(inputReader, calculator);	1✔
NEW 60	else if (inputFormat.equals(InputFormat.JSON_ARRAY))	×
61	return new JSONArrayRecordReader(inputReader, calculator);	×
62	else
NEW 63	throw new IllegalArgumentException("Unsupported input format: " + inputFormat);	×
64	case XML:
65	return new XMLRecordReader(inputReader, calculator);	1✔
66	case CSV:
67	default:
68	return new CSVRecordReader(inputReader, calculator);	1✔
69	}
70	}
71
72	public static ResultWriter getResultWriter(String outputFormat, String outputFile) throws IOException {
73
74	if (outputFormat == null) {	1✔
75	outputFormat = FilenameUtils.getExtension(outputFile);	1✔
76	}
77
78	switch (outputFormat) {	1✔
79	case App.JSON:
80	case App.NDJSON:
81	return new JSONResultWriter(outputFile);	1✔
82	case App.CSVJSON:
83	return new CSVJSONResultWriter(outputFile);	1✔
84	case App.CSV:
85	default:
86	return new CSVResultWriter(outputFile);	1✔
87	}
88	}
89
90	public static ResultWriter getResultWriter(String outputFormat) {
91	switch (outputFormat) {	1✔
92	case App.NDJSON:
93	return new JSONResultWriter();	1✔
94	case App.CSVJSON:
95	return new CSVJSONResultWriter();	1✔
96	case App.CSV:
97	default:
98	return new CSVResultWriter();	1✔
99	}
100	}
101	}

pkiraly / metadata-qa-api / #675

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