How to use

ConjureParserUtils

in

com.palantir.conjure.defs

  /**
   * Deserializes {@link ConjureDefinition} from their YAML representations in the given files.
   */
  public static ConjureDefinition parse(Collection<File> files) {
    return ConjureParserUtils.parseConjureDef(
        files.stream().map(ConjureParser::parse).collect(Collectors.toList()));
  }
}

@Override
public TypeDefinition visit(EnumTypeDefinition def) {
  return ConjureParserUtils.parseEnumType(
      ConjureParserUtils.createTypeName(name, def, defaultPackage), def);
}

@Override
public TypeDefinition visit(AliasTypeDefinition def) {
  return ConjureParserUtils.parseAliasType(
      ConjureParserUtils.createTypeName(name, def, defaultPackage), def, typeResolver);
}

@Override
public TypeDefinition visit(ObjectTypeDefinition def) {
  return ConjureParserUtils.parseObjectType(
      ConjureParserUtils.createTypeName(name, def, defaultPackage), def, typeResolver);
}

  Map<TypeName, TypeDefinition> objects = parseObjects(parsed.types(), typeResolver);
  Map<TypeName, TypeDefinition> importedObjects = parseImportObjects(parsed.types().conjureImports());
  Map<TypeName, TypeDefinition> allObjects = Maps.newHashMap();
  allObjects.putAll(objects);
    servicesBuilder.add(parseService(
        service,
        TypeName.of(serviceName.name(), parseConjurePackage(service.conjurePackage())),
        typeResolver,
        dealiasingVisitor));
  errorsBuilder.addAll(parseErrors(parsed.types().definitions(), typeResolver));
});

private static EndpointDefinition parseEndpoint(
    String name,
    com.palantir.conjure.parser.services.EndpointDefinition def,
    PathString basePath,
    Optional<AuthType> defaultAuth,
    ReferenceTypeResolver typeResolver,
    DealiasingTypeVisitor dealiasingVisitor) {
  HttpPath httpPath = parseHttpPath(def, basePath);
  EndpointDefinition endpoint = EndpointDefinition.builder()
      .endpointName(EndpointName.of(name))
      .httpMethod(HttpMethod.valueOf(def.http().method()))
      .httpPath(httpPath)
      .auth(def.auth().map(ConjureParserUtils::parseAuthType).orElse(defaultAuth))
      .args(parseArgs(def.args(), httpPath, typeResolver))
      .markers(parseMarkers(def.markers(), typeResolver))
      .returns(def.returns().map(t -> t.visit(new ConjureTypeParserVisitor(typeResolver))))
      .docs(def.docs().map(Documentation::of))
      .deprecated(def.deprecated().map(Documentation::of))
      .build();
  EndpointDefinitionValidator.validateAll(endpoint, dealiasingVisitor);
  return endpoint;
}

  @Override
  public TypeDefinition visit(UnionTypeDefinition def) {
    return ConjureParserUtils.parseUnionType(
        ConjureParserUtils.createTypeName(name, def, defaultPackage), def, typeResolver);
  }
}

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();
}

static ServiceDefinition parseService(
    com.palantir.conjure.parser.services.ServiceDefinition parsed,
    TypeName serviceName,
    ReferenceTypeResolver typeResolver,
    DealiasingTypeVisitor dealiasingVisitor) {
  List<EndpointDefinition> endpoints = new ArrayList<>();
  parsed.endpoints().forEach((name, def) -> endpoints.add(
      ConjureParserUtils.parseEndpoint(
          name,
          def,
          parsed.basePath(),
          parseAuthType(parsed.defaultAuth()),
          typeResolver,
          dealiasingVisitor)));
  ServiceDefinition service = ServiceDefinition.builder()
      .serviceName(serviceName)
      .docs(parsed.docs().map(Documentation::of))
      .addAllEndpoints(endpoints)
      .build();
  ServiceDefinitionValidator.validateAll(service);
  return service;
}

@Test
public void resolvesImportedAliases() {
  ConjureDefinition conjureDefinition = ConjureParserUtils.parseConjureDef(
      ImmutableList.of(ConjureParser.parse(new File("src/test/resources/example-conjure-imports.yml"))));
  assertThat(conjureDefinition.getTypes()).hasSize(1);
}

  @Test
  @Ignore
  public void handlesNonJavaExternalType() {
    ConjureDefinition conjureDefinition = ConjureParserUtils.parseConjureDef(
        ImmutableList.of(ConjureParser.parse(new File("src/test/resources/example-external-types.yml"))));
  }
}

@Test
public void testConjureSpec() {
  // test positive cases
  testCaseDef.positive().orElse(new TreeMap<>()).entrySet().stream().forEach(entry -> {
    String testName = String.format("positive case %s", entry.getKey());
    String yml = getYmlAsString(testName, entry.getValue().conjure());
    try {
      ConjureParserUtils.parseConjureDef(ImmutableList.of(MAPPER.readValue(yml, ConjureSourceFile.class)));
    } catch (Exception e) {
      Assertions.fail("Conjure for case should be valid according to the spec: " + testName, e);
    }
  });
  // test negative cases
  testCaseDef.negative().orElse(new TreeMap<>()).entrySet().stream().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());
    }
  });
}