diff --git a/.baseline/checkstyle/checkstyle.xml b/.baseline/checkstyle/checkstyle.xml index efc641dfd..43ec38a3a 100644 --- a/.baseline/checkstyle/checkstyle.xml +++ b/.baseline/checkstyle/checkstyle.xml @@ -84,11 +84,13 @@ + org.apache.commons.lang3.Validate.*, + org.assertj.core.api.Assertions.*, + org.mockito.Mockito.*"/> @@ -127,6 +129,11 @@ + + + + + @@ -417,6 +424,7 @@ + @@ -430,7 +438,7 @@ - + @@ -463,7 +471,7 @@ - + diff --git a/build.gradle b/build.gradle index c3030148a..da1f8a2d4 100644 --- a/build.gradle +++ b/build.gradle @@ -29,7 +29,7 @@ buildscript { classpath 'com.netflix.nebula:gradle-info-plugin:5.1.1' classpath 'com.jfrog.bintray.gradle:gradle-bintray-plugin:1.8.4' classpath 'com.netflix.nebula:nebula-publishing-plugin:14.0.0' - classpath 'com.palantir.baseline:gradle-baseline-java:0.51.1' + classpath 'com.palantir.baseline:gradle-baseline-java:2.26.0' classpath 'com.palantir.gradle.conjure:gradle-conjure:4.13.4' classpath 'com.palantir.gradle.gitversion:gradle-git-version:0.12.2' classpath 'gradle.plugin.org.inferred:gradle-processors:3.1.0' diff --git a/conjure-core/src/main/java/com/palantir/conjure/defs/ConjureParserUtils.java b/conjure-core/src/main/java/com/palantir/conjure/defs/ConjureParserUtils.java index 73da9db35..3f8900e50 100644 --- a/conjure-core/src/main/java/com/palantir/conjure/defs/ConjureParserUtils.java +++ b/conjure-core/src/main/java/com/palantir/conjure/defs/ConjureParserUtils.java @@ -72,6 +72,7 @@ import com.palantir.conjure.spec.UnionDefinition; import com.palantir.conjure.visitor.DealiasingTypeVisitor; import com.palantir.conjure.visitor.TypeDefinitionVisitor; +import com.palantir.logsafe.exceptions.SafeIllegalArgumentException; import java.util.ArrayList; import java.util.Collection; import java.util.List; @@ -95,9 +96,8 @@ public static String parseConjurePackage(com.palantir.conjure.parser.types.names public static String parsePackageOrElseThrow( Optional conjurePackage, Optional defaultPackage) { - String packageName = conjurePackage - .map(p -> p.name()) - .orElseGet(() -> defaultPackage.orElseThrow(() -> new IllegalArgumentException( + String packageName = conjurePackage.map(p -> p.name()).orElseGet(() -> + defaultPackage.orElseThrow(() -> new SafeIllegalArgumentException( // TODO(rfink): Better errors: Can we provide context on where exactly no package was provided? "Must provide default conjure package or " + "explicit conjure package for every object and service"))); @@ -373,7 +373,7 @@ private static Optional parseAuthType( case NONE: return Optional.empty(); default: - throw new IllegalArgumentException("Unrecognized auth type."); + throw new SafeIllegalArgumentException("Unrecognized auth type."); } } @@ -415,14 +415,14 @@ private static ParameterType parseParameterType( return ParameterType.body(BodyParameterType.of()); } case HEADER: - String headerParamId = argumentDef.paramId().map(id -> id.name()).orElse(argName.get()); + String headerParamId = argumentDef.paramId().map(id -> id.name()).orElseGet(() -> argName.get()); return ParameterType.header(HeaderParameterType.of(ParameterId.of(headerParamId))); case PATH: return ParameterType.path(PathParameterType.of()); case BODY: return ParameterType.body(BodyParameterType.of()); case QUERY: - String queryParamId = argumentDef.paramId().map(id -> id.name()).orElse(argName.get()); + String queryParamId = argumentDef.paramId().map(id -> id.name()).orElseGet(() -> argName.get()); return ParameterType.query(QueryParameterType.of(ParameterId.of(queryParamId))); default: throw new IllegalArgumentException("Unknown parameter type: " + argumentDef.paramType()); diff --git a/conjure-core/src/main/java/com/palantir/conjure/defs/ConjureTypeParserVisitor.java b/conjure-core/src/main/java/com/palantir/conjure/defs/ConjureTypeParserVisitor.java index 2bb2cab75..b29889d10 100644 --- a/conjure-core/src/main/java/com/palantir/conjure/defs/ConjureTypeParserVisitor.java +++ b/conjure-core/src/main/java/com/palantir/conjure/defs/ConjureTypeParserVisitor.java @@ -105,7 +105,7 @@ public ConjureTypeParserVisitor(ReferenceTypeResolver nameResolver) { } @Override - public Type visitAny(AnyType type) { + public Type visitAny(AnyType _type) { return Type.primitive(com.palantir.conjure.spec.PrimitiveType.ANY); } @@ -146,12 +146,12 @@ public Type visitSet(SetType type) { } @Override - public Type visitBinary(BinaryType type) { + public Type visitBinary(BinaryType _type) { return Type.primitive(com.palantir.conjure.spec.PrimitiveType.BINARY); } @Override - public Type visitDateTime(DateTimeType type) { + public Type visitDateTime(DateTimeType _type) { return Type.primitive(com.palantir.conjure.spec.PrimitiveType.DATETIME); } } diff --git a/conjure-core/src/main/java/com/palantir/conjure/defs/validator/ConjureDefinitionValidator.java b/conjure-core/src/main/java/com/palantir/conjure/defs/validator/ConjureDefinitionValidator.java index cc3f79be2..8e8ea4493 100644 --- a/conjure-core/src/main/java/com/palantir/conjure/defs/validator/ConjureDefinitionValidator.java +++ b/conjure-core/src/main/java/com/palantir/conjure/defs/validator/ConjureDefinitionValidator.java @@ -122,10 +122,8 @@ public void validate(ConjureDefinition definition) { // create mapping from object type name -> names of reference types that are fields of that type Multimap typeToRefFields = HashMultimap.create(); - definition.getTypes().stream().forEach(type -> - getReferenceType(type) - .ifPresent(entry -> typeToRefFields.put( - type.accept(TypeDefinitionVisitor.TYPE_NAME), entry))); + definition.getTypes().forEach(type -> getReferenceType(type).ifPresent(entry -> + typeToRefFields.put(type.accept(TypeDefinitionVisitor.TYPE_NAME), entry))); for (TypeName name : typeToRefFields.keySet()) { verifyTypeHasNoRecursiveDefinitions(name, typeToRefFields, new ArrayList<>()); @@ -181,14 +179,14 @@ public void validate(ConjureDefinition definition) { // create mapping for resolving reference types during validation Map definitionMap = definition.getTypes().stream().collect( Collectors.toMap(entry -> entry.accept(TypeDefinitionVisitor.TYPE_NAME), entry -> entry)); - definition.getTypes().stream().forEach(def -> validateTypeDefinition(def, definitionMap)); + definition.getTypes().forEach(def -> validateTypeDefinition(def, definitionMap)); definition.getErrors().forEach(def -> validateErrorDefinition(def, definitionMap)); definition.getServices().forEach(def -> validateServiceDefinition(def, definitionMap)); } private static void validateServiceDefinition(ServiceDefinition serviceDef, Map definitionMap) { - serviceDef.getEndpoints().stream().forEach(endpoint -> { + serviceDef.getEndpoints().forEach(endpoint -> { endpoint.getArgs().stream() .filter(arg -> recursivelyFindNestedOptionals(arg.getType(), definitionMap, false)) .findAny() @@ -199,9 +197,8 @@ private static void validateServiceDefinition(ServiceDefinition serviceDef, }); endpoint.getReturns().ifPresent(returnType -> { if (recursivelyFindNestedOptionals(returnType, definitionMap, false)) { - throw new IllegalStateException( - "Illegal nested optionals found in return type of endpoint " - + endpoint.getEndpointName().get()); + throw new IllegalStateException("Illegal nested optionals found in return type of endpoint " + + endpoint.getEndpointName().get()); } }); }); @@ -224,7 +221,7 @@ private static void validateTypeDefinition(TypeDefinition typeDef, typeDef.accept(new TypeDefinition.Visitor() { @Override - public Void visitAlias(AliasDefinition value) { + public Void visitAlias(AliasDefinition _value) { AliasDefinition aliasDef = typeDef.accept(TypeDefinitionVisitor.ALIAS); if (recursivelyFindNestedOptionals(aliasDef.getAlias(), definitionMap, false)) { throw new IllegalStateException( @@ -234,42 +231,40 @@ public Void visitAlias(AliasDefinition value) { } @Override - public Void visitObject(ObjectDefinition value) { + public Void visitObject(ObjectDefinition _value) { ObjectDefinition objectDefinition = typeDef.accept(TypeDefinitionVisitor.OBJECT); objectDefinition.getFields().stream() - .filter(fieldDefinition -> recursivelyFindNestedOptionals( - fieldDefinition.getType(), definitionMap, false)) + .filter(fieldDefinition -> + recursivelyFindNestedOptionals(fieldDefinition.getType(), definitionMap, false)) .findAny() .ifPresent(found -> { - throw new IllegalStateException( - "Illegal nested optionals found in object " - + objectDefinition.getTypeName().getName()); + throw new IllegalStateException("Illegal nested optionals found in object " + + objectDefinition.getTypeName().getName()); }); return null; } @Override - public Void visitUnion(UnionDefinition value) { + public Void visitUnion(UnionDefinition _value) { UnionDefinition unionDefinition = typeDef.accept(TypeDefinitionVisitor.UNION); unionDefinition.getUnion().stream() - .filter(fieldDefinition -> recursivelyFindNestedOptionals( - fieldDefinition.getType(), definitionMap, false)) + .filter(fieldDefinition -> + recursivelyFindNestedOptionals(fieldDefinition.getType(), definitionMap, false)) .findAny() .ifPresent(found -> { - throw new IllegalStateException( - "Illegal nested optionals found in union " - + unionDefinition.getTypeName().getName()); + throw new IllegalStateException("Illegal nested optionals found in union " + + unionDefinition.getTypeName().getName()); }); return null; } @Override - public Void visitEnum(EnumDefinition value) { + public Void visitEnum(EnumDefinition _value) { return null; } @Override - public Void visitUnknown(String unknownType) { + public Void visitUnknown(String _unknownType) { return null; } }); diff --git a/conjure-core/src/main/java/com/palantir/conjure/defs/validator/EndpointDefinitionValidator.java b/conjure-core/src/main/java/com/palantir/conjure/defs/validator/EndpointDefinitionValidator.java index c38fe80e3..956335043 100644 --- a/conjure-core/src/main/java/com/palantir/conjure/defs/validator/EndpointDefinitionValidator.java +++ b/conjure-core/src/main/java/com/palantir/conjure/defs/validator/EndpointDefinitionValidator.java @@ -39,6 +39,7 @@ import com.palantir.conjure.visitor.ParameterTypeVisitor; import com.palantir.conjure.visitor.TypeDefinitionVisitor; import com.palantir.conjure.visitor.TypeVisitor; +import com.palantir.logsafe.exceptions.SafeRuntimeException; import java.util.Arrays; import java.util.HashSet; import java.util.List; @@ -274,51 +275,51 @@ public void validate(EndpointDefinition definition, DealiasingTypeVisitor dealia } private static Boolean recursivelyValidate(Type type, DealiasingTypeVisitor visitor) { - return visitor.dealias(type).fold( - typeDefinition -> typeDefinition.accept(TypeDefinitionVisitor.IS_ENUM), - subType -> subType.accept(new Type.Visitor() { - @Override - public Boolean visitPrimitive(PrimitiveType value) { - return value.get() != PrimitiveType.Value.ANY; - } - - @Override - public Boolean visitOptional(OptionalType value) { - return recursivelyValidate(value.getItemType(), visitor); - } - - @Override - public Boolean visitList(ListType value) { - return recursivelyValidate(value.getItemType(), visitor); - } - - @Override - public Boolean visitSet(SetType value) { - return recursivelyValidate(value.getItemType(), visitor); - } - - @Override - public Boolean visitMap(MapType value) { - return false; - } - - // The cases below should not be handled here, since they implicitly handled by the - // DealiasingTypeVisitor above - @Override - public Boolean visitReference(TypeName value) { - throw new RuntimeException("Unexpected type when validating query parameters"); - } - - @Override - public Boolean visitExternal(ExternalReference value) { - throw new RuntimeException("Unexpected type when validating query parameters"); - } - - @Override - public Boolean visitUnknown(String unknownType) { - throw new RuntimeException("Unexpected type when validating query parameters"); - } - })); + return visitor.dealias(type) + .fold(typeDefinition -> typeDefinition.accept(TypeDefinitionVisitor.IS_ENUM), subType -> + subType.accept(new Type.Visitor() { + @Override + public Boolean visitPrimitive(PrimitiveType value) { + return value.get() != PrimitiveType.Value.ANY; + } + + @Override + public Boolean visitOptional(OptionalType value) { + return recursivelyValidate(value.getItemType(), visitor); + } + + @Override + public Boolean visitList(ListType value) { + return recursivelyValidate(value.getItemType(), visitor); + } + + @Override + public Boolean visitSet(SetType value) { + return recursivelyValidate(value.getItemType(), visitor); + } + + @Override + public Boolean visitMap(MapType _value) { + return false; + } + + // The cases below should not be handled here, since they implicitly handled by the + // DealiasingTypeVisitor above + @Override + public Boolean visitReference(TypeName _value) { + throw new SafeRuntimeException("Unexpected type when validating query parameters"); + } + + @Override + public Boolean visitExternal(ExternalReference _value) { + throw new SafeRuntimeException("Unexpected type when validating query parameters"); + } + + @Override + public Boolean visitUnknown(String _unknownType) { + throw new SafeRuntimeException("Unexpected type when validating query parameters"); + } + })); } } diff --git a/conjure-core/src/main/java/com/palantir/conjure/defs/validator/HttpPathValidator.java b/conjure-core/src/main/java/com/palantir/conjure/defs/validator/HttpPathValidator.java index 500e5b505..cd7ce8f45 100644 --- a/conjure-core/src/main/java/com/palantir/conjure/defs/validator/HttpPathValidator.java +++ b/conjure-core/src/main/java/com/palantir/conjure/defs/validator/HttpPathValidator.java @@ -74,9 +74,9 @@ public static void validate(HttpPath httpPath) { // verify that path template variables are unique Set templateVars = new HashSet<>(); - new UriTemplate(path.toString()).getTemplateVariables().stream().forEach(var -> { - Preconditions.checkState(!templateVars.contains(var), - "Path parameter %s appears more than once in path %s", var, path); + new UriTemplate(path.toString()).getTemplateVariables().forEach(var -> { + Preconditions.checkState( + !templateVars.contains(var), "Path parameter %s appears more than once in path %s", var, path); templateVars.add(var); }); diff --git a/conjure-core/src/main/java/com/palantir/conjure/defs/validator/UnionDefinitionValidator.java b/conjure-core/src/main/java/com/palantir/conjure/defs/validator/UnionDefinitionValidator.java index 8f02bdf17..9e8f9c495 100644 --- a/conjure-core/src/main/java/com/palantir/conjure/defs/validator/UnionDefinitionValidator.java +++ b/conjure-core/src/main/java/com/palantir/conjure/defs/validator/UnionDefinitionValidator.java @@ -48,8 +48,9 @@ private static final class NoTrailingUnderscoreValidator implements ConjureValid @Override public void validate(UnionDefinition definition) { - definition.getUnion().stream().forEach(fieldDef -> { - Preconditions.checkArgument(!fieldDef.getFieldName().get().endsWith("_"), + definition.getUnion().forEach(fieldDef -> { + Preconditions.checkArgument( + !fieldDef.getFieldName().get().endsWith("_"), "Union member key must not end with an underscore: %s", fieldDef.getFieldName().get()); }); @@ -74,10 +75,11 @@ private static boolean isValidJavaIdentifier(String key) { @Override public void validate(UnionDefinition definition) { - definition.getUnion().stream().forEach(fieldDef -> { - Preconditions.checkArgument(!Strings.isNullOrEmpty(fieldDef.getFieldName().get()), - "Union member key must not be empty"); - Preconditions.checkArgument(isValidJavaIdentifier(fieldDef.getFieldName().get()), + definition.getUnion().forEach(fieldDef -> { + com.palantir.logsafe.Preconditions.checkArgument( + !Strings.isNullOrEmpty(fieldDef.getFieldName().get()), "Union member key must not be empty"); + Preconditions.checkArgument( + isValidJavaIdentifier(fieldDef.getFieldName().get()), "Union member key must be a valid Java identifier: %s", fieldDef.getFieldName().get()); }); @@ -89,9 +91,9 @@ private static final class NoClobberTypeValidator implements ConjureValidator { - Preconditions.checkArgument(!fieldDef.getFieldName().get().equals("type"), - "Union member key must not be 'type'"); + definition.getUnion().forEach(fieldDef -> { + com.palantir.logsafe.Preconditions.checkArgument( + !fieldDef.getFieldName().get().equals("type"), "Union member key must not be 'type'"); }); } } diff --git a/conjure-core/src/main/java/com/palantir/conjure/parser/services/ArgumentDefinition.java b/conjure-core/src/main/java/com/palantir/conjure/parser/services/ArgumentDefinition.java index 772a35eab..9e5c63233 100644 --- a/conjure-core/src/main/java/com/palantir/conjure/parser/services/ArgumentDefinition.java +++ b/conjure-core/src/main/java/com/palantir/conjure/parser/services/ArgumentDefinition.java @@ -99,7 +99,7 @@ class Builder extends ImmutableArgumentDefinition.Builder {} class ArgumentDefinitionDeserializer extends JsonDeserializer { @SuppressWarnings("deprecation") @Override - public ArgumentDefinition deserialize(JsonParser parser, DeserializationContext context) + public ArgumentDefinition deserialize(JsonParser parser, DeserializationContext _context) throws IOException, JsonProcessingException { String candidate = parser.getValueAsString(); diff --git a/conjure-core/src/main/java/com/palantir/conjure/parser/services/AuthDefinition.java b/conjure-core/src/main/java/com/palantir/conjure/parser/services/AuthDefinition.java index 2c767b10a..858da55dd 100644 --- a/conjure-core/src/main/java/com/palantir/conjure/parser/services/AuthDefinition.java +++ b/conjure-core/src/main/java/com/palantir/conjure/parser/services/AuthDefinition.java @@ -16,12 +16,12 @@ package com.palantir.conjure.parser.services; -import static com.google.common.base.Preconditions.checkArgument; import com.fasterxml.jackson.annotation.JsonCreator; import com.fasterxml.jackson.annotation.JsonValue; import com.fasterxml.jackson.databind.annotation.JsonDeserialize; import com.palantir.conjure.defs.ConjureImmutablesStyle; +import com.palantir.logsafe.Preconditions; import java.util.Locale; import org.immutables.value.Value; @@ -81,7 +81,7 @@ static AuthDefinition fromString(String value) { id = "NONE"; break; case COOKIE: - checkArgument(parts.length == 2, "Cookie authorization type must include a cookie name"); + Preconditions.checkArgument(parts.length == 2, "Cookie authorization type must include a cookie name"); id = parts[1]; break; default: diff --git a/conjure-core/src/main/java/com/palantir/conjure/parser/types/BaseObjectTypeDefinition.java b/conjure-core/src/main/java/com/palantir/conjure/parser/types/BaseObjectTypeDefinition.java index 13479fcd5..6865ba665 100644 --- a/conjure-core/src/main/java/com/palantir/conjure/parser/types/BaseObjectTypeDefinition.java +++ b/conjure-core/src/main/java/com/palantir/conjure/parser/types/BaseObjectTypeDefinition.java @@ -29,6 +29,7 @@ import com.palantir.conjure.parser.types.complex.UnionTypeDefinition; import com.palantir.conjure.parser.types.names.ConjurePackage; import com.palantir.conjure.parser.types.reference.AliasTypeDefinition; +import com.palantir.logsafe.exceptions.SafeIllegalArgumentException; import java.io.IOException; import java.util.Optional; @@ -44,7 +45,8 @@ public interface BaseObjectTypeDefinition { class BaseObjectTypeDefinitionDeserializer extends JsonDeserializer { @Override - public BaseObjectTypeDefinition deserialize(JsonParser parser, DeserializationContext ctxt) throws IOException { + public BaseObjectTypeDefinition deserialize(JsonParser parser, DeserializationContext _ctxt) + throws IOException { TreeNode tree = parser.readValueAsTree(); if (tree.get("fields") != null) { return ObjectTypeDefinition.fromJson(parser, tree); @@ -57,7 +59,7 @@ public BaseObjectTypeDefinition deserialize(JsonParser parser, DeserializationCo } else if (tree.get("namespace") != null) { return ErrorTypeDefinition.fromJson(parser, tree); } else { - throw new IllegalArgumentException( + throw new SafeIllegalArgumentException( "Unrecognized definition, types must have either fields, values or an alias defined."); } } diff --git a/conjure-core/src/main/java/com/palantir/conjure/parser/types/TypeParser.java b/conjure-core/src/main/java/com/palantir/conjure/parser/types/TypeParser.java index 171d5684e..0a28f9845 100644 --- a/conjure-core/src/main/java/com/palantir/conjure/parser/types/TypeParser.java +++ b/conjure-core/src/main/java/com/palantir/conjure/parser/types/TypeParser.java @@ -212,7 +212,7 @@ public T parse(ParserState input) throws ParseException { return instance; } - public static TypeFromString of(String type, T instance, Class metric) { + public static TypeFromString of(String type, T instance, Class _metric) { return new TypeFromString<>(type, instance); } } diff --git a/conjure-core/src/main/java/com/palantir/conjure/parser/types/complex/EnumValueDefinition.java b/conjure-core/src/main/java/com/palantir/conjure/parser/types/complex/EnumValueDefinition.java index 43040e281..dfa861763 100644 --- a/conjure-core/src/main/java/com/palantir/conjure/parser/types/complex/EnumValueDefinition.java +++ b/conjure-core/src/main/java/com/palantir/conjure/parser/types/complex/EnumValueDefinition.java @@ -44,8 +44,7 @@ class Builder extends ImmutableEnumValueDefinition.Builder {} class EnumValueDeserializer extends JsonDeserializer { @SuppressWarnings("deprecation") @Override - public EnumValueDefinition deserialize(JsonParser parser, DeserializationContext ctxt) - throws IOException { + public EnumValueDefinition deserialize(JsonParser parser, DeserializationContext _ctxt) throws IOException { String candidate = parser.getValueAsString(); if (candidate != null) { return builder().value(candidate).build(); diff --git a/conjure-core/src/main/java/com/palantir/conjure/parser/types/complex/ErrorTypeDefinition.java b/conjure-core/src/main/java/com/palantir/conjure/parser/types/complex/ErrorTypeDefinition.java index 36f5b962c..568684f28 100644 --- a/conjure-core/src/main/java/com/palantir/conjure/parser/types/complex/ErrorTypeDefinition.java +++ b/conjure-core/src/main/java/com/palantir/conjure/parser/types/complex/ErrorTypeDefinition.java @@ -46,7 +46,7 @@ public interface ErrorTypeDefinition extends BaseObjectTypeDefinition { Map unsafeArgs(); @Override - default T visit(TypeDefinitionVisitor visitor) { + default T visit(TypeDefinitionVisitor _visitor) { throw new UnsupportedOperationException(); } diff --git a/conjure-core/src/main/java/com/palantir/conjure/parser/types/complex/FieldDefinition.java b/conjure-core/src/main/java/com/palantir/conjure/parser/types/complex/FieldDefinition.java index 2af098348..aebe6d680 100644 --- a/conjure-core/src/main/java/com/palantir/conjure/parser/types/complex/FieldDefinition.java +++ b/conjure-core/src/main/java/com/palantir/conjure/parser/types/complex/FieldDefinition.java @@ -45,7 +45,7 @@ static FieldDefinition of(ConjureType type) { class FieldDefinitionDeserializer extends JsonDeserializer { @SuppressWarnings("deprecation") @Override - public FieldDefinition deserialize(JsonParser parser, DeserializationContext context) throws IOException { + public FieldDefinition deserialize(JsonParser parser, DeserializationContext _context) throws IOException { String candidate = parser.getValueAsString(); if (candidate != null) { diff --git a/conjure-core/src/test/java/com/palantir/conjure/defs/ConjureDefTest.java b/conjure-core/src/test/java/com/palantir/conjure/defs/ConjureDefTest.java index 47c560699..af2300652 100644 --- a/conjure-core/src/test/java/com/palantir/conjure/defs/ConjureDefTest.java +++ b/conjure-core/src/test/java/com/palantir/conjure/defs/ConjureDefTest.java @@ -38,7 +38,7 @@ public void resolvesImportedAliases() { @Test @Ignore public void handlesNonJavaExternalType() { - ConjureDefinition conjureDefinition = ConjureParserUtils.parseConjureDef( + ConjureParserUtils.parseConjureDef( ImmutableList.of(ConjureParser.parse(new File("src/test/resources/example-external-types.yml")))); } } diff --git a/conjure-core/src/test/java/com/palantir/conjure/defs/ConjureSpecTest.java b/conjure-core/src/test/java/com/palantir/conjure/defs/ConjureSpecTest.java index 80712fb80..9ebd27712 100644 --- a/conjure-core/src/test/java/com/palantir/conjure/defs/ConjureSpecTest.java +++ b/conjure-core/src/test/java/com/palantir/conjure/defs/ConjureSpecTest.java @@ -69,7 +69,7 @@ public ConjureSpecTest(TestCaseDefinition testCaseDef) { @Test public void testConjureSpec() { // test positive cases - testCaseDef.positive().orElse(new TreeMap<>()).entrySet().stream().forEach(entry -> { + testCaseDef.positive().orElseGet(() -> new TreeMap<>()).entrySet().forEach(entry -> { String testName = String.format("positive case %s", entry.getKey()); String yml = getYmlAsString(testName, entry.getValue().conjure()); try { @@ -80,16 +80,21 @@ public void testConjureSpec() { }); // test negative cases - testCaseDef.negative().orElse(new TreeMap<>()).entrySet().stream().forEach(entry -> { + testCaseDef.negative().orElseGet(() -> new TreeMap<>()).entrySet().forEach(entry -> { String testName = String.format("negative case %s", entry.getKey()); String yml = getYmlAsString(testName, entry.getValue().conjure()); try { ConjureParserUtils.parseConjureDef(ImmutableList.of(MAPPER.readValue(yml, ConjureSourceFile.class))); Assertions.fail("Conjure for case should be invalid according to the spec: " + testName); } catch (Exception e) { - Assertions.assertThat(e).withFailMessage("Failure message for case did not match expectation: " - + testName + "\nMessage:\n" + e.getMessage() + "\ndid not contain:\n" - + entry.getValue().expectedError()).hasMessageContaining(entry.getValue().expectedError()); + Assertions.assertThat(e) + .withFailMessage("Failure message for case did not match expectation: " + + testName + + "\nMessage:\n" + + e.getMessage() + + "\ndid not contain:\n" + + entry.getValue().expectedError()) + .hasMessageContaining(entry.getValue().expectedError()); } }); } diff --git a/conjure-generator-common/src/main/java/com/palantir/conjure/either/Either.java b/conjure-generator-common/src/main/java/com/palantir/conjure/either/Either.java index 294aff146..e37234127 100644 --- a/conjure-generator-common/src/main/java/com/palantir/conjure/either/Either.java +++ b/conjure-generator-common/src/main/java/com/palantir/conjure/either/Either.java @@ -39,7 +39,7 @@ abstract class Left implements Either { abstract L value(); @Override - public T fold(Function mapLeft, Function mapRight) { + public T fold(Function mapLeft, Function _mapRight) { return mapLeft.apply(value()); } } @@ -50,7 +50,7 @@ abstract class Right implements Either { abstract R value(); @Override - public T fold(Function mapLeft, Function mapRight) { + public T fold(Function _mapLeft, Function mapRight) { return mapRight.apply(value()); } } diff --git a/conjure-generator-common/src/main/java/com/palantir/conjure/visitor/AuthTypeVisitor.java b/conjure-generator-common/src/main/java/com/palantir/conjure/visitor/AuthTypeVisitor.java index 886f61c6e..928cd1481 100644 --- a/conjure-generator-common/src/main/java/com/palantir/conjure/visitor/AuthTypeVisitor.java +++ b/conjure-generator-common/src/main/java/com/palantir/conjure/visitor/AuthTypeVisitor.java @@ -43,31 +43,31 @@ public CookieAuthType visitCookie(CookieAuthType value) { private static class DefaultIsAuthTypeVisitor implements AuthType.Visitor { @Override - public Boolean visitHeader(HeaderAuthType value) { + public Boolean visitHeader(HeaderAuthType _value) { return false; } @Override - public Boolean visitCookie(CookieAuthType value) { + public Boolean visitCookie(CookieAuthType _value) { return false; } @Override - public Boolean visitUnknown(String unknownType) { + public Boolean visitUnknown(String _unknownType) { return false; } } private static class IsHeaderAuthTypeVisitor extends DefaultIsAuthTypeVisitor { @Override - public Boolean visitHeader(HeaderAuthType value) { + public Boolean visitHeader(HeaderAuthType _value) { return true; } } private static class IsCookieAuthTypeVisitor extends DefaultIsAuthTypeVisitor { @Override - public Boolean visitCookie(CookieAuthType value) { + public Boolean visitCookie(CookieAuthType _value) { return true; } } diff --git a/conjure-generator-common/src/main/java/com/palantir/conjure/visitor/ParameterTypeVisitor.java b/conjure-generator-common/src/main/java/com/palantir/conjure/visitor/ParameterTypeVisitor.java index c804d6312..4f9f8b432 100644 --- a/conjure-generator-common/src/main/java/com/palantir/conjure/visitor/ParameterTypeVisitor.java +++ b/conjure-generator-common/src/main/java/com/palantir/conjure/visitor/ParameterTypeVisitor.java @@ -81,55 +81,55 @@ public PathParameterType visitPath(PathParameterType value) { private static class IsParameterTypeVisitor implements ParameterType.Visitor { @Override - public Boolean visitBody(BodyParameterType value) { + public Boolean visitBody(BodyParameterType _value) { return false; } @Override - public Boolean visitHeader(HeaderParameterType value) { + public Boolean visitHeader(HeaderParameterType _value) { return false; } @Override - public Boolean visitPath(PathParameterType value) { + public Boolean visitPath(PathParameterType _value) { return false; } @Override - public Boolean visitQuery(QueryParameterType value) { + public Boolean visitQuery(QueryParameterType _value) { return false; } @Override - public Boolean visitUnknown(String unknownType) { + public Boolean visitUnknown(String _unknownType) { return false; } } private static class IsBodyParameterType extends IsParameterTypeVisitor { @Override - public Boolean visitBody(BodyParameterType value) { + public Boolean visitBody(BodyParameterType _value) { return true; } } private static class IsPathParameterType extends IsParameterTypeVisitor { @Override - public Boolean visitPath(PathParameterType value) { + public Boolean visitPath(PathParameterType _value) { return true; } } private static class IsHeaderParameterType extends IsParameterTypeVisitor { @Override - public Boolean visitHeader(HeaderParameterType value) { + public Boolean visitHeader(HeaderParameterType _value) { return true; } } private static class IsQueryParameterType extends IsParameterTypeVisitor { @Override - public Boolean visitQuery(QueryParameterType value) { + public Boolean visitQuery(QueryParameterType _value) { return true; } } diff --git a/conjure-generator-common/src/main/java/com/palantir/conjure/visitor/TypeDefinitionVisitor.java b/conjure-generator-common/src/main/java/com/palantir/conjure/visitor/TypeDefinitionVisitor.java index 729f298c1..11c61c5c7 100644 --- a/conjure-generator-common/src/main/java/com/palantir/conjure/visitor/TypeDefinitionVisitor.java +++ b/conjure-generator-common/src/main/java/com/palantir/conjure/visitor/TypeDefinitionVisitor.java @@ -112,55 +112,55 @@ public T visitUnknown(String unknownType) { private static class IsAliasDefinitionVisitor extends DefaultIsTypeDefinitionVisitor { @Override - public Boolean visitAlias(AliasDefinition value) { + public Boolean visitAlias(AliasDefinition _value) { return true; } } private static class IsObjectDefinitionVisitor extends DefaultIsTypeDefinitionVisitor { @Override - public Boolean visitObject(ObjectDefinition value) { + public Boolean visitObject(ObjectDefinition _value) { return true; } } private static class IsEnumDefinitionVisitor extends DefaultIsTypeDefinitionVisitor { @Override - public Boolean visitEnum(EnumDefinition value) { + public Boolean visitEnum(EnumDefinition _value) { return true; } } private static class IsUnionDefinitionVisitor extends DefaultIsTypeDefinitionVisitor { @Override - public Boolean visitUnion(UnionDefinition value) { + public Boolean visitUnion(UnionDefinition _value) { return true; } } private static class DefaultIsTypeDefinitionVisitor implements TypeDefinition.Visitor { @Override - public Boolean visitAlias(AliasDefinition value) { + public Boolean visitAlias(AliasDefinition _value) { return false; } @Override - public Boolean visitEnum(EnumDefinition value) { + public Boolean visitEnum(EnumDefinition _value) { return false; } @Override - public Boolean visitObject(ObjectDefinition value) { + public Boolean visitObject(ObjectDefinition _value) { return false; } @Override - public Boolean visitUnion(UnionDefinition value) { + public Boolean visitUnion(UnionDefinition _value) { return false; } @Override - public Boolean visitUnknown(String unknownType) { + public Boolean visitUnknown(String _unknownType) { return false; } } diff --git a/conjure-generator-common/src/main/java/com/palantir/conjure/visitor/TypeVisitor.java b/conjure-generator-common/src/main/java/com/palantir/conjure/visitor/TypeVisitor.java index ba323b215..7a9373c02 100644 --- a/conjure-generator-common/src/main/java/com/palantir/conjure/visitor/TypeVisitor.java +++ b/conjure-generator-common/src/main/java/com/palantir/conjure/visitor/TypeVisitor.java @@ -37,64 +37,64 @@ private TypeVisitor() {} private static class IsPrimitiveTypeVisitor extends IsTypeVisitor { @Override - public Boolean visitPrimitive(PrimitiveType value) { + public Boolean visitPrimitive(PrimitiveType _value) { return true; } } private static class IsOptionalTypeVisitor extends IsTypeVisitor { @Override - public Boolean visitOptional(OptionalType value) { + public Boolean visitOptional(OptionalType _value) { return true; } } private static class IsListTypeVisitor extends IsTypeVisitor { @Override - public Boolean visitList(ListType value) { + public Boolean visitList(ListType _value) { return true; } } private static class IsSetTypeVisitor extends IsTypeVisitor { @Override - public Boolean visitSet(SetType value) { + public Boolean visitSet(SetType _value) { return true; } } private static class IsMapTypeVisitor extends IsTypeVisitor { @Override - public Boolean visitMap(MapType value) { + public Boolean visitMap(MapType _value) { return true; } } private static class IsReferenceTypeVisitor extends IsTypeVisitor { @Override - public Boolean visitReference(TypeName value) { + public Boolean visitReference(TypeName _value) { return true; } @Override - public Boolean visitExternal(ExternalReference value) { + public Boolean visitExternal(ExternalReference _value) { return true; } } private static class IsPrimitiveOrReferenceType extends IsTypeVisitor { @Override - public Boolean visitPrimitive(PrimitiveType value) { + public Boolean visitPrimitive(PrimitiveType _value) { return true; } @Override - public Boolean visitReference(TypeName value) { + public Boolean visitReference(TypeName _value) { return true; } @Override - public Boolean visitExternal(ExternalReference value) { + public Boolean visitExternal(ExternalReference _value) { return true; } } @@ -115,42 +115,42 @@ public Boolean visitPrimitive(PrimitiveType value) { private static class IsTypeVisitor implements Type.Visitor { @Override - public Boolean visitPrimitive(PrimitiveType value) { + public Boolean visitPrimitive(PrimitiveType _value) { return false; } @Override - public Boolean visitOptional(OptionalType value) { + public Boolean visitOptional(OptionalType _value) { return false; } @Override - public Boolean visitList(ListType value) { + public Boolean visitList(ListType _value) { return false; } @Override - public Boolean visitSet(SetType value) { + public Boolean visitSet(SetType _value) { return false; } @Override - public Boolean visitMap(MapType value) { + public Boolean visitMap(MapType _value) { return false; } @Override - public Boolean visitReference(TypeName value) { + public Boolean visitReference(TypeName _value) { return false; } @Override - public Boolean visitExternal(ExternalReference value) { + public Boolean visitExternal(ExternalReference _value) { return false; } @Override - public Boolean visitUnknown(String unknownType) { + public Boolean visitUnknown(String _unknownType) { return false; } } @@ -158,7 +158,7 @@ public Boolean visitUnknown(String unknownType) { private static class DefaultTypeVisitor implements Type.Visitor { @Override - public T visitPrimitive(PrimitiveType value) { + public T visitPrimitive(PrimitiveType _value) { return null; }