@JsonCreator public static PrimitiveType fromString(String type) { return fromTypeName(TypeName.of(type)) .orElseThrow(() -> new IllegalArgumentException("Unknown primitive type: " + type)); }
@Test public void testParser_refType() throws ParseException { assertThat(TypeParser.INSTANCE.parse("Foo")) .isEqualTo(LocalReferenceType.of(TypeName.of("Foo"))); }
static List<ErrorDefinition> parseErrors( NamedTypesDefinition defs, ConjureTypeParserVisitor.ReferenceTypeResolver typeResolver) { Optional<String> defaultPackage = defs.defaultConjurePackage().map(p -> p.name()); ImmutableList.Builder<ErrorDefinition> errorsBuidler = ImmutableList.builder(); errorsBuidler.addAll(defs.errors().entrySet().stream().map(entry -> { TypeName typeName = TypeName.of( entry.getKey().name(), parsePackageOrElseThrow(entry.getValue().conjurePackage(), defaultPackage)); return parseErrorType(typeName, entry.getValue(), typeResolver); }).collect(Collectors.toList())); return errorsBuidler.build(); }
@Test public void testParser_foreignRefType() throws ParseException { assertThat(TypeParser.INSTANCE.parse("bar.Foo")) .isEqualTo(ForeignReferenceType.of(Namespace.of("bar"), TypeName.of("Foo"))); }
static Map<TypeName, TypeDefinition> parseObjects( com.palantir.conjure.parser.types.TypesDefinition parsed, ConjureTypeParserVisitor.ReferenceTypeResolver typeResolver) { Optional<String> defaultPackage = parsed.definitions().defaultConjurePackage().map(ConjurePackage::name); // no need to use validator here since TypeDefinitionParserVisitor calls each TypeDefinition parser that // validates its type. return parsed.definitions().objects().entrySet().stream() .map(entry -> entry.getValue().visit( new TypeDefinitionParserVisitor(entry.getKey().name(), defaultPackage, typeResolver))) .collect(Collectors.toMap(td -> td.accept(TypeDefinitionVisitor.TYPE_NAME), td -> td)); }
@Override public LocalReferenceType parse(ParserState input) throws ParseException { input.mark(); String typeReference = REF_PARSER.parse(input); if (typeReference == null) { input.rewind(); return null; } input.release(); ConjureMetrics.incrementCounter(LocalReferenceType.class); return LocalReferenceType.of(TypeName.of(typeReference)); } }
servicesBuilder.add(parseService( service, TypeName.of(serviceName.name(), parseConjurePackage(service.conjurePackage())), typeResolver, dealiasingVisitor));
@Test public void testConjureExternalImports() { ConjureSourceFile conjure = ConjureParser.parse(new File("src/test/resources/example-external-types.yml")); assertThat(conjure.types().imports().get(TypeName.of("ExampleAnyImport")).baseType()) .isEqualTo(PrimitiveType.fromString("any")); }
private static Type resolveFromTypeName( com.palantir.conjure.parser.types.names.TypeName name, TypesDefinition types) { Optional<String> defaultPackage = types.definitions().defaultConjurePackage().map(ConjureParserUtils::parseConjurePackage); BaseObjectTypeDefinition maybeDirectDef = types.definitions().objects().get(name); String conjurePackage; String typeName; if (maybeDirectDef == null) { ExternalTypeDefinition maybeExternalDef = types.imports().get(name); if (maybeExternalDef == null) { throw new IllegalStateException("Unknown LocalReferenceType: " + name); } String externalPath = maybeExternalDef.external().java(); int lastIndex = externalPath.lastIndexOf("."); conjurePackage = externalPath.substring(0, lastIndex); typeName = externalPath.substring(lastIndex + 1); return Type.external(ExternalReference.builder() .externalReference(TypeName.of(typeName, conjurePackage)) .fallback(ConjureParserUtils.parsePrimitiveType(maybeExternalDef.baseType())) .build()); } else { // Conjure-defined object conjurePackage = ConjureParserUtils.parsePackageOrElseThrow( maybeDirectDef.conjurePackage(), defaultPackage); return Type.reference(TypeName.of(name.name(), conjurePackage)); } } }
@Test public void testParseAlias_validReference() throws IOException { assertThat(mapper.readValue("alias: Foo", BaseObjectTypeDefinition.class)) .isEqualTo(AliasTypeDefinition.builder().alias(LocalReferenceType.of(TypeName.of("Foo"))).build()); }
@Override public ForeignReferenceType parse(ParserState input) throws ParseException { String namespace = NAMESPACE_PARSER.parse(input); if (Parsers.nullOrUnexpected(Parsers.expect(".").parse(input))) { return null; } String ref = TypeReferenceParser.REF_PARSER.parse(input); ConjureMetrics.incrementCounter(ForeignReferenceType.class); return ForeignReferenceType.of(Namespace.of(namespace), TypeName.of(ref)); } }
ConjureSourceFile.builder() .types(TypesDefinition.builder() .putImports(TypeName.of("ResourceIdentifier"), ExternalTypeDefinition.javaType( "com.palantir.ri.ResourceIdentifier", PrimitiveType.STRING)) .definitions(NamedTypesDefinition.builder() .defaultConjurePackage(ConjurePackage.of("test.api")) .putObjects(TypeName.of("SimpleObject"), ObjectTypeDefinition.builder() .putFields(FieldName.of("stringField"), FieldDefinition.of(PrimitiveType.STRING)) .build()) .putObjects(TypeName.of("StringAlias"), AliasTypeDefinition.builder() .alias(PrimitiveType.STRING) .build()) .build()) .build()) .putServices(TypeName.of("TestService"), ServiceDefinition.builder() .doNotUseName("Test Service") .conjurePackage(ConjurePackage.of("test.api")) .args(ImmutableMap.of(ParameterName.of("foo"), ArgumentDefinition.builder() .paramType(ArgumentDefinition.ParamType.HEADER) .type(LocalReferenceType.of(TypeName.of("StringAlias"))) .build())) .build())