congrats Icon
New! Tabnine Pro 14-day free trial
Start a free trial
Tabnine Logo
ConjureParserUtils
Code IndexAdd Tabnine to your IDE (free)

How to use
ConjureParserUtils
in
com.palantir.conjure.defs

Best Java code snippets using com.palantir.conjure.defs.ConjureParserUtils (Showing top 12 results out of 315)

origin: palantir/conjure

  /**
   * 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()));
  }
}
origin: palantir/conjure

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

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

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

  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));
});
origin: palantir/conjure

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;
}
origin: palantir/conjure

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

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();
}
origin: palantir/conjure

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;
}
origin: palantir/conjure

@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);
}
origin: palantir/conjure

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

@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());
    }
  });
}
com.palantir.conjure.defsConjureParserUtils

Javadoc

Utility methods used to parse com.palantir.conjure.parser definitions into com.palantir.conjure.defsdefinitions.

Most used methods

  • parseConjureDef
  • createTypeName
  • parseAliasType
  • parseArgs
  • parseAuthType
  • parseConjurePackage
  • parseEndpoint
  • parseEnumType
  • parseErrorType
  • parseErrors
  • parseField
  • parseFieldName
  • parseField,
  • parseFieldName,
  • parseHttpPath,
  • parseImportObjects,
  • parseMarkers,
  • parseObjectType,
  • parseObjects,
  • parsePackageOrElseThrow,
  • parseParameterType,
  • parsePrimitiveType

Popular in Java

  • Finding current android device location
  • compareTo (BigDecimal)
  • setScale (BigDecimal)
  • getApplicationContext (Context)
  • Menu (java.awt)
  • Rectangle (java.awt)
    A Rectangle specifies an area in a coordinate space that is enclosed by the Rectangle object's top-
  • SocketTimeoutException (java.net)
    This exception is thrown when a timeout expired on a socket read or accept operation.
  • Enumeration (java.util)
    A legacy iteration interface.New code should use Iterator instead. Iterator replaces the enumeration
  • Base64 (org.apache.commons.codec.binary)
    Provides Base64 encoding and decoding as defined by RFC 2045.This class implements section 6.8. Base
  • IsNull (org.hamcrest.core)
    Is the value null?
  • Top 17 Free Sublime Text Plugins
Tabnine Logo
  • Products

    Search for Java codeSearch for JavaScript code
  • IDE Plugins

    IntelliJ IDEAWebStormVisual StudioAndroid StudioEclipseVisual Studio CodePyCharmSublime TextPhpStormVimAtomGoLandRubyMineEmacsJupyter NotebookJupyter LabRiderDataGripAppCode
  • Company

    About UsContact UsCareers
  • Resources

    FAQBlogTabnine AcademyStudentsTerms of usePrivacy policyJava Code IndexJavascript Code Index
Get Tabnine for your IDE now