import org.raml.v2.api.model.v10.api.Api; //导入依赖的package包/类
public static void main(String[] args) throws Exception  {

        RamlModelResult ramlModelResult =
                new RamlModelBuilder().buildApi(
                        new FileReader("/Users/jpbelang/IdeaProjects/raml-java-tools/raml-to-pojo/src/test/resources/org/raml/ramltopojo/union/union-primitive-type.raml"),
                        ".");
        if (ramlModelResult.hasErrors()) {
            for (ValidationResult validationResult : ramlModelResult.getValidationResults()) {
                System.err.println(validationResult.getMessage());
            }
            throw new Exception();
        }

        final Api api = ramlModelResult.getApiV10();
        RamlToPojo ramlToPojo = RamlToPojoBuilder.builder(api)
                .inPackage("my.packaging")
                .fetchTypes(fromAnywhere())
                .findTypes(everyWhere()).build();

        ramlToPojo.buildPojos().createAllTypes("/Users/jpbelang/IdeaProjects/raml-java-tools/garbage/src/main/java");
    }
 

import org.raml.v2.api.model.v10.api.Api; //导入依赖的package包/类
public static TypeFetcher fromTypes() {

        return new TypeFetcher() {

            // this is technically invalid, as different apis might call.  Won't happen, but could.
            // make better
            Iterable<TypeDeclaration> foundInApi;
            @Override
            public TypeDeclaration fetchType(Api api, final String name) throws GenerationException {

                return FluentIterable.from(Optional.fromNullable(foundInApi).or(api.types()))
                        .firstMatch(namedPredicate(name)).or(fail(name));
            }

        };
    }
 

import org.raml.v2.api.model.v10.api.Api; //导入依赖的package包/类
@Test
public void inheritanceWithDiscriminatorAndValue() throws Exception {

    Api api = RamlLoader.load(this.getClass().getResourceAsStream("inheritance-with-discriminatorvalue-type.raml"), ".");
    ObjectTypeHandler handler = new ObjectTypeHandler(RamlLoader.findTypes("foo", api.types()));

    CreationResult r = handler.create(createGenerationContext(api));

    System.err.println(r.getInterface().toString());
    System.err.println(r.getImplementation().toString());


    assertThat(r.getImplementation().get(), is(allOf(
            name(equalTo("FooImpl")),
            fields(containsInAnyOrder(
                    allOf(fieldName(equalTo("kind")), fieldType(equalTo(ClassName.get(String.class))), initializer(equalTo("\"myOwnValue\""))),
                    allOf(fieldName(equalTo("right")), fieldType(equalTo(ClassName.get(String.class)))),
                    allOf(fieldName(equalTo("name")), fieldType(equalTo(ClassName.get(String.class))))
            ))
    )));


}
 

import org.raml.v2.api.model.v10.api.Api; //导入依赖的package包/类
public static void main(String[] args) throws IOException {
    // URL url = Main.class.getResource("api.raml");
    URL url = Main.class.getResource("fun.raml");

    Reader reader = new InputStreamReader(url.openStream());

    RamlModelResult ramlModelResult = new RamlModelBuilder().buildApi(reader, url.getFile());
    if (ramlModelResult.hasErrors()) {
        for (ValidationResult validationResult : ramlModelResult.getValidationResults()) {
            System.err.println(validationResult);
        }
    } else {

        Api realApi = ramlModelResult.getApiV10();
        System.err.println("grr " + realApi.annotationTypes().get(0).name());
    }
}
 

import org.raml.v2.api.model.v10.api.Api; //导入依赖的package包/类
public static void main(String[] args) {

        RamlModelResult ramlModelResult = new RamlModelBuilder().buildApi(new File(Query.class.getResource("/api.raml").getFile()));
        if (ramlModelResult.hasErrors()) {
            for (ValidationResult validationResult : ramlModelResult.getValidationResults()) {
                System.out.println(validationResult.getMessage());
            }

        } else {
            Api api = ramlModelResult.getApiV10();

            List<Resource> tr = from(api).select(Selectors.allResources()).toList();
            for (Resource resource : tr) {
                System.err.println(resource.resourcePath());
            }
        }
    }
 

import org.raml.v2.api.model.v10.api.Api; //导入依赖的package包/类
/**
 * Validates the body, headers, uri and query parameters of the request of the given context.
 *
 * @param context the context holding the requesz
 * @param body    the request body to validate
 * @param method  the method to validate the request aginst
 * @return validation errors
 */
public Optional<ValidationErrors> validateRequest(final Context context, final TypedData body, final Method method) {
    final List<ValidationError> errors = new ArrayList<>();

    if (disableValidation(context.getRequest().getHeaders(), ValidationFlag.request)) {
        return wrapAndLogErrors(errors);
    }

    final Api api = context.get(RamlModelRepository.class).getApi();

    errors.addAll(validateQueryParameters(context.getRequest(), method));
    errors.addAll(validateRequestHeaders(context.getRequest().getHeaders(), method));

    final String contentType = Optional.ofNullable(body.getContentType().getType()).orElse(
            !method.body().isEmpty() ? method.body().get(0).name() :
                    !api.mediaType().isEmpty() ? api.mediaType().get(0).value() : "application/json"
    );
    final Optional<TypeDeclaration> bodyTypeDeclaration = method.body().stream()
            .filter(typeDeclaration -> contentType.equals(typeDeclaration.name())).findFirst();

    errors.addAll(bodyTypeDeclaration
            .map(bodyTypeDecl -> validate(body.getText(), bodyTypeDecl, ValidationKind.body, "request"))
            .orElse(Collections.emptyList()));

    return wrapAndLogErrors(errors);
}
 

import org.raml.v2.api.model.v10.api.Api; //导入依赖的package包/类
public StringWriter preprocess(Context ctx, final Path filePath, final Api api) throws IOException {
    final Integer port = ctx.getServerConfig().getPort();
    final StringWriter stringWriter = new StringWriter();
    final String baseUri = api.baseUri().value();
    final List<SecurityScheme> oauthSchemes = api.securitySchemes().stream().filter(securityScheme -> securityScheme.type().equals("OAuth 2.0")).collect(Collectors.toList());
    String content = new String(Files.readAllBytes(filePath), Charsets.UTF_8);

    ObjectMapper mapper = new ObjectMapper(); // can reuse, share globally
    final JsonNode file = mapper.readValue(filePath.toFile(), JsonNode.class);
    if (file.has("baseUri")) {
        content = content.replaceAll(baseUri, "http://localhost:" + port.toString() + "/api");
    }

    if (!oauthSchemes.isEmpty()) {
        for (SecurityScheme scheme : oauthSchemes) {
            content = content.replaceAll(scheme.settings().accessTokenUri().value(), "http://localhost:" + port.toString() + "/auth/" + scheme.name());
        }
    }

    return stringWriter.append(content);
}
 

import org.raml.v2.api.model.v10.api.Api; //导入依赖的package包/类
@Override
public RamlRoot buildRamlRoot(String ramlFileUrl) throws InvalidRamlResourceException {
    RamlModelResult ramlModelResult = new RamlModelBuilder().buildApi(ramlFileUrl);
    if (ramlModelResult.hasErrors()) {
        List<String> errors = ramlModelResult.getValidationResults()
                .stream()
                .map(validationResult -> validationResult.getMessage())
                .collect(Collectors.toList());
        throw new InvalidRamlResourceException(ramlFileUrl, errors);
    }

    // The Api is created by RamlModelBuilder during runtime via a yagi ModelProxyBuilder.
    // In org.raml.v2 there is no direct implementation for Api interface during compile time.
    Api api = ramlModelResult.getApiV10();
    return new RJP10V2RamlRoot(api);
}
 

import org.raml.v2.api.model.v10.api.Api; //导入依赖的package包/类
@Test
public void pojoToRamlTypeBuilder() throws Exception {

    PojoToRamlImpl pojoToRaml = new PojoToRamlImpl(FieldClassParser.factory(), RamlAdjuster.NULL_ADJUSTER);
    Result types =  pojoToRaml.classToRaml(Fun.class);

    RamlDocumentBuilder ramlDocumentBuilder = RamlDocumentBuilder
            .document()
            .baseUri("http://google.com")
            .title("hello")
            .version("1")
            .withTypes(types.allTypes().toArray(new TypeDeclarationBuilder[0]));

    Api api = ramlDocumentBuilder.buildModel();

    final GrammarPhase grammarPhase = new GrammarPhase(RamlHeader.getFragmentRule(new RamlHeader(RAML_10, Default).getFragment()));
    Node node = ((NodeModel) api).getNode();
    Node checked = grammarPhase.apply(node);
    List<ErrorNode> errors = checked.findDescendantsWith(ErrorNode.class);
    for (ErrorNode error : errors) {
        System.err.println("error: " + error.getErrorMessage());
    }

    List<TypeDeclaration> buildTypes = api.types();

    assertEquals(2, buildTypes.size());
    assertEquals("Fun", buildTypes.get(0).name());
    assertEquals("SubFun", buildTypes.get(1).name());

}
 

import org.raml.v2.api.model.v10.api.Api; //导入依赖的package包/类
public Api buildModel() {

        NodeModelFactory fac = binding.bindingOf(Api.class);
        Node node = buildNode();
        NodeModel model = fac.create(node);
        return  ModelProxyBuilder.createModel(Api.class, model, binding);
    }
 

import org.raml.v2.api.model.v10.api.Api; //导入依赖的package包/类
public static TypeFinder inTypes() {

        return new TypeFinder() {
            @Override
            public Iterable<TypeDeclaration> findTypes(Api api) {

                return api.types();
            }
        };
    }
 

import org.raml.v2.api.model.v10.api.Api; //导入依赖的package包/类
public static TypeFinder inLibraries() {

        return new TypeFinder() {
            @Override
            public Iterable<TypeDeclaration> findTypes(Api api) {

                List<TypeDeclaration> foundTypes = new ArrayList<>();
                Utils.goThroughLibraries(foundTypes, new HashSet<String>(), api.uses());
                return foundTypes;
            }
        };
    }
 

import org.raml.v2.api.model.v10.api.Api; //导入依赖的package包/类
public static  TypeFinder everyWhere() {

        return new TypeFinder() {
            @Override
            public Iterable<TypeDeclaration> findTypes(Api api) {

                return FluentIterable.from(api.types()).append(Utils.goThroughLibraries(new ArrayList<TypeDeclaration>(), new HashSet<String>(), api.uses()));
            }
        };
    }
 

import org.raml.v2.api.model.v10.api.Api; //导入依赖的package包/类
public static TypeFetcher fromLibraries() {

        return new TypeFetcher() {

            Iterable<TypeDeclaration> foundInApi;

            @Override
            public TypeDeclaration fetchType(Api api, final String name) throws GenerationException {
                return FluentIterable.from(Optional.fromNullable(foundInApi).or(Utils.goThroughLibraries(new ArrayList<TypeDeclaration>(), new HashSet<String>(), api.uses())))
                        .firstMatch(namedPredicate(name)).or(fail(name));
            }
        };
    }
 

import org.raml.v2.api.model.v10.api.Api; //导入依赖的package包/类
public static  TypeFetcher fromAnywhere() {

        return new TypeFetcher() {
            Iterable<TypeDeclaration> foundInApi;

            @Override
            public TypeDeclaration fetchType(Api api, final String name) throws GenerationException {
                return FluentIterable.from(Optional.fromNullable(foundInApi).or(FluentIterable.from(api.types()).append(Utils.goThroughLibraries(new ArrayList<TypeDeclaration>(), new HashSet<String>(), api.uses()))))
                        .firstMatch(namedPredicate(name)).or(fail(name));
            }

        };
    }
 

import org.raml.v2.api.model.v10.api.Api; //导入依赖的package包/类
@Test(expected = GenerationException.class)
public void arrayUnion() throws Exception {

    Api api = RamlLoader.load(this.getClass().getResourceAsStream("union-array-type.raml"), ".");
    UnionTypeHandler handler = new UnionTypeHandler(findTypes("foo", api.types()));

    handler.create(new GenerationContextImpl(PluginManager.NULL, api, TypeFetchers.fromTypes(), "bar.pack"));
}
 

import org.raml.v2.api.model.v10.api.Api; //导入依赖的package包/类
@Test
public void internalIntIsNotNewInlineType() {

    Api api = RamlLoader.load(this.getClass().getResourceAsStream("inline-types.raml"), ".");
    ObjectTypeDeclaration decl = RamlLoader.findTypes("foo", api.types());
    TypeDeclaration property = findProperty(decl, "internalInt");

    assertFalse(TypeDeclarationType.isNewInlineType(property));
}
 

import org.raml.v2.api.model.v10.api.Api; //导入依赖的package包/类
@Test
public void simpleObjectIsNotNewInlineType() {

    Api api = RamlLoader.load(this.getClass().getResourceAsStream("inline-types.raml"), ".");
    ObjectTypeDeclaration decl = RamlLoader.findTypes("foo", api.types());
    TypeDeclaration property = findProperty(decl, "unextended");

    assertFalse(TypeDeclarationType.isNewInlineType(property));
}
 

import org.raml.v2.api.model.v10.api.Api; //导入依赖的package包/类
@Test
public void extendedObjectIsNotNewInlineType() {

    Api api = RamlLoader.load(this.getClass().getResourceAsStream("inline-types.raml"), ".");
    ObjectTypeDeclaration decl = RamlLoader.findTypes("foo", api.types());
    TypeDeclaration property = findProperty(decl, "extendedFromOne");

    assertFalse(TypeDeclarationType.isNewInlineType(property));
}
 

import org.raml.v2.api.model.v10.api.Api; //导入依赖的package包/类
@Test
public void extendedObjectWithExtraPropertiesIsNewInlineType() {

    Api api = RamlLoader.load(this.getClass().getResourceAsStream("inline-types.raml"), ".");
    ObjectTypeDeclaration decl = RamlLoader.findTypes("foo", api.types());
    TypeDeclaration property = findProperty(decl, "extendedFromOneWithExtraProperty");

    assertTrue(TypeDeclarationType.isNewInlineType(property));
}