com.hltech.vaunt.validator.schema.JsonSchemaValidator.validate(JsonSchema,JsonSchema) - Code Metrics - Inspection of "Minor refactors of Validators" - HLTech/vaunt - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( d91c1f...3f9a31 )

by Filip

created 2019-08-12 08:50 UTC

validate(JsonSchema,JsonSchema) C

↳ Parent: com.hltech.vaunt.validator.schema.JsonSchemaValidator

Complexity

Conditions

Size

Total Lines	60
Code Lines	45

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	9
eloc	45
c	0
b	0
f	0
dl	0
loc	60
rs	6.4666

How to fix Long Method

package com.hltech.vaunt.validator.schema;

import com.fasterxml.jackson.module.jsonSchema.JsonSchema;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Objects;
import java.util.Set;
import java.util.function.BiPredicate;
import java.util.stream.Collectors;
import java.util.stream.IntStream;

public abstract class JsonSchemaValidator {
    static final String ERROR_FORMAT = "Schema with id %s has not matching %s - consumer: %s, provider: %s";
    static final String ERROR_FORMAT_SHORT = "Schema with id %s has not matching %s";

    public abstract Class<?> supportsSchemaType();

    public List<String> validate(JsonSchema consumerSchema, JsonSchema providerSchema) {
        List<String> errors = new ArrayList<>();

        if (!equals(consumerSchema.get$ref(), providerSchema.get$ref())) {
            errors.add(String.format(ERROR_FORMAT,
                    consumerSchema.getId(),
                    "$ref",
                    consumerSchema.get$ref(),
                    providerSchema.get$ref()));
        }

        if (!equals(consumerSchema.get$schema(), providerSchema.get$schema())) {
            errors.add(String.format(ERROR_FORMAT,
                    consumerSchema.getId(),
                    "$schema",
                    consumerSchema.get$schema(),
                    providerSchema.get$schema()));
        }

        if (!arraysEquals(consumerSchema.getDisallow(), providerSchema.getDisallow(), Object::equals)) {
            errors.add(String.format(ERROR_FORMAT,
                    consumerSchema.getId(),
                    "disallow",
                    jsonArrayToString(consumerSchema.getDisallow()),
                    jsonArrayToString(providerSchema.getDisallow())));
        }

        if (!arraysEquals(consumerSchema.getExtends(), providerSchema.getExtends(), Object::equals)) {
            errors.add(String.format(ERROR_FORMAT,
                    consumerSchema.getId(),
                    "extends",
                    jsonArrayToString(consumerSchema.getExtends()),
                    jsonArrayToString(providerSchema.getExtends())));
        }

        if (isRequired(consumerSchema) && !isRequired(providerSchema)) {
            errors.add(String.format(ERROR_FORMAT,
                    consumerSchema.getId(),
                    "required",
                    consumerSchema.getRequired(),
                    providerSchema.getRequired()));
        }

        if (!equals(consumerSchema.getReadonly(), providerSchema.getReadonly())) {
            errors.add(String.format(ERROR_FORMAT,
                    consumerSchema.getId(),
                    "readonly",
                    consumerSchema.getReadonly(),
                    providerSchema.getReadonly()));
        }

        if (!equals(consumerSchema.getDescription(), providerSchema.getDescription())) {
            errors.add(String.format(ERROR_FORMAT,
                    consumerSchema.getId(),
                    "description",
                    consumerSchema.getDescription(),
                    providerSchema.getDescription()));
        }

        return errors;
    }

    private boolean isRequired(JsonSchema schema) {
        return schema.getRequired() != null && schema.getRequired();
    }

    boolean equals(Object object1, Object object2) {
        return Objects.equals(object1, object2);
    }

    <T> boolean arraysEquals(T[] array1, T[] array2, BiPredicate<T, T> checker) {
        if (array1 == null) {
            return array2 == null;
        }
        if (array2 == null) {
            return false;
        }

        return array1.length == array2.length && IntStream.range(0, array1.length)
                .allMatch(i -> checker.test(array1[i], array2[i]));
    }

    private String jsonArrayToString(JsonSchema[] array) {
        String content = Arrays.stream(array)
                .map(this::jsonToString)
                .collect(Collectors.joining(", "));

        return "[" + content + "]";
    }

    String jsonToString(JsonSchema object) {
        return "JsonSchema(id=" + object.getId() + ")";
    }

    boolean isEnumValid(Set<String> consumerEnums, Set<String> providerEnums) {
        if (representsString(consumerEnums) && representsEnum(providerEnums)) {
            return false;
        }

        if (representsEnum(consumerEnums) && representsEnum(providerEnums)) {
            return providerEnums.containsAll(consumerEnums);
        }

        return true;
    }

    private boolean representsEnum(Set<String> enums) {
        return enums.size() > 0;
    }

    private boolean representsString(Set<String> enums) {
        return enums.size() == 0;
    }
}


1			package com.hltech.vaunt.validator.schema;
2
3			import com.fasterxml.jackson.module.jsonSchema.JsonSchema;
4
5			import java.util.ArrayList;
6			import java.util.Arrays;
7			import java.util.List;
8			import java.util.Objects;
9			import java.util.Set;
10			import java.util.function.BiPredicate;
11			import java.util.stream.Collectors;
12			import java.util.stream.IntStream;
13
14			public abstract class JsonSchemaValidator {
15			static final String ERROR_FORMAT = "Schema with id %s has not matching %s - consumer: %s, provider: %s";
16			static final String ERROR_FORMAT_SHORT = "Schema with id %s has not matching %s";
17
18			public abstract Class<?> supportsSchemaType();
19
20			public List<String> validate(JsonSchema consumerSchema, JsonSchema providerSchema) {
21			List<String> errors = new ArrayList<>();
22
23			if (!equals(consumerSchema.get$ref(), providerSchema.get$ref())) {
24			errors.add(String.format(ERROR_FORMAT,
25			consumerSchema.getId(),
26			"$ref",
27			consumerSchema.get$ref(),
28			providerSchema.get$ref()));
29			}
30
31			if (!equals(consumerSchema.get$schema(), providerSchema.get$schema())) {
32			errors.add(String.format(ERROR_FORMAT,
33			consumerSchema.getId(),
34			"$schema",
35			consumerSchema.get$schema(),
36			providerSchema.get$schema()));
37			}
38
39			if (!arraysEquals(consumerSchema.getDisallow(), providerSchema.getDisallow(), Object::equals)) {
40			errors.add(String.format(ERROR_FORMAT,
41			consumerSchema.getId(),
42			"disallow",
43			jsonArrayToString(consumerSchema.getDisallow()),
44			jsonArrayToString(providerSchema.getDisallow())));
45			}
46
47			if (!arraysEquals(consumerSchema.getExtends(), providerSchema.getExtends(), Object::equals)) {
48			errors.add(String.format(ERROR_FORMAT,
49			consumerSchema.getId(),
50			"extends",
51			jsonArrayToString(consumerSchema.getExtends()),
52			jsonArrayToString(providerSchema.getExtends())));
53			}
54
55			if (isRequired(consumerSchema) && !isRequired(providerSchema)) {
56			errors.add(String.format(ERROR_FORMAT,
57			consumerSchema.getId(),
58			"required",
59			consumerSchema.getRequired(),
60			providerSchema.getRequired()));
61			}
62
63			if (!equals(consumerSchema.getReadonly(), providerSchema.getReadonly())) {
64			errors.add(String.format(ERROR_FORMAT,
65			consumerSchema.getId(),
66			"readonly",
67			consumerSchema.getReadonly(),
68			providerSchema.getReadonly()));
69			}
70
71			if (!equals(consumerSchema.getDescription(), providerSchema.getDescription())) {
72			errors.add(String.format(ERROR_FORMAT,
73			consumerSchema.getId(),
74			"description",
75			consumerSchema.getDescription(),
76			providerSchema.getDescription()));
77			}
78
79			return errors;
80			}
81
82			private boolean isRequired(JsonSchema schema) {
83			return schema.getRequired() != null && schema.getRequired();
84			}
85
86			boolean equals(Object object1, Object object2) {
87			return Objects.equals(object1, object2);
88			}
89
90			<T> boolean arraysEquals(T[] array1, T[] array2, BiPredicate<T, T> checker) {
91			if (array1 == null) {
92			return array2 == null;
93			}
94			if (array2 == null) {
95			return false;
96			}
97
98			return array1.length == array2.length && IntStream.range(0, array1.length)
99			.allMatch(i -> checker.test(array1[i], array2[i]));
100			}
101
102			private String jsonArrayToString(JsonSchema[] array) {
103			String content = Arrays.stream(array)
104			.map(this::jsonToString)
105			.collect(Collectors.joining(", "));
106
107			return "[" + content + "]";
108			}
109
110			String jsonToString(JsonSchema object) {
111			return "JsonSchema(id=" + object.getId() + ")";
112			}
113
114			boolean isEnumValid(Set<String> consumerEnums, Set<String> providerEnums) {
115			if (representsString(consumerEnums) && representsEnum(providerEnums)) {
116			return false;
117			}
118
119			if (representsEnum(consumerEnums) && representsEnum(providerEnums)) {
120			return providerEnums.containsAll(consumerEnums);
121			}
122
123			return true;
124			}
125
126			private boolean representsEnum(Set<String> enums) {
127			return enums.size() > 0;
128			}
129
130			private boolean representsString(Set<String> enums) {
131			return enums.size() == 0;
132			}
133			}
134

HLTech / vaunt

Push — master ( d91c1f...3f9a31 )

validate(JsonSchema,JsonSchema) C

Complexity

Size

Duplication

Importance

How to fix Long Method

Long Method

Duplication Side-by-Side

Filter issues like