Java Raml类代码示例

import org.raml.model.Raml; //导入依赖的package包/类
/**
 * Determine if the given `MockServer` location has obeyed the RAML API specifications.
 *
 * @param client           The `MockServer` client
 * @param responseObeyMode The level of obeying responses will adhere to.
 * @param alsoCheckMethods By default, only GET, POST, PUT and DELETE methods are checked.  Add HEAD, OPTIONS, etc. if needed here.
 * @return The result of the expectation validations.
 * @throws java.lang.IllegalStateException If the specification has not been initialized.
 * @see ResponseObeyMode
 */
public Result obeyedBy(MockServerClient client, ResponseObeyMode responseObeyMode, String... alsoCheckMethods) {
    Raml raml = this.raml.orElseThrow(() -> new IllegalStateException(String.format("[ %s ] specification has not been initialized", name)));
    Result result = new Result();
    List<String> methodsToCheck = newArrayList(DEFAULT_METHODS_TO_CHECK);
    methodsToCheck.addAll(newArrayList(alsoCheckMethods));

    Arrays.asList(client.retrieveExistingExpectations(null))
            .stream()
            .map(e -> {
                ApiSpecification specification = new ApiSpecification(raml);
                ApiExpectation expectation = new ApiExpectation(specification, e);
                if (!methodsToCheck.contains(expectation.getMethod()))
                    return Optional.<ExpectationError>empty();

                return new ExpectationValidator(expectation, getValidators(expectation, responseObeyMode)).validate();
            })
            .filter(Optional::isPresent)
            .map(Optional::get)
            .forEach(result::withErrors);

    return result;
}
 

import org.raml.model.Raml; //导入依赖的package包/类
public void generate() throws IOException {
    Path path = codegenConfig.getInputPath();
    LOG.info("RAML: {}", path.toAbsolutePath());
    if (path.endsWith(".raml")) {
        LOG.warn("Wrong path - should end with .raml");
        return;
    }

    Raml raml = new RamlDocumentBuilder(new FileResourceLoader(path.getParent().toFile()))
            .build(path.getFileName().toString());

    ReqSpecSupplField baseReqSpec = new ReqSpecSupplField();
    ReqSpecField req = new ReqSpecField();

    new RootApiClase(new NestedConfigClass(raml.getTitle(), baseReqSpec, req))
            .javaFile(raml, codegenConfig.getBasePackage())
            .writeTo(codegenConfig.getOutputPath());

    raml.getResources().values().parallelStream().forEach(resource -> {
        new ResourceClassBuilder().withCodegenConfig(codegenConfig).withResource(resource).withReq(req).generate();
    });
}
 

import org.raml.model.Raml; //导入依赖的package包/类
@Override
public String toString(Object o, String formatString, Locale locale) {
    final Raml raml = (Raml) o;
    if (raml.getBaseUri() == null) {
        return "";
    }
    switch (formatString) {
        case "baseUri":
            if (raml.getProtocols() == null || raml.getProtocols().isEmpty()) {
                return raml.getBaseUri();
            }
            final int pos = raml.getBaseUri().indexOf("://");
            final String rest = pos < 0 ? raml.getBaseUri() : raml.getBaseUri().substring(pos + 3);
            if (raml.getProtocols().size() == 2) {
                return "http(s)://" + rest;
            }
            return raml.getProtocols().get(0).toString().toLowerCase() + "://" + rest;
        default:
            throw new IllegalArgumentException("unknown format '" + formatString + "'");
    }
}
 

import org.raml.model.Raml; //导入依赖的package包/类
public StringRenderer(Raml raml, ResourceCache resourceCache) {
    this.raml = raml;
    this.resourceCache = resourceCache;
    final ScriptEngine engine = new ScriptEngineManager().getEngineByExtension("js");
    final Invocable invocable = (Invocable) engine;
    try {
        engine.eval("var window=this;");
        //beautify.js: changed default operators like 'bla || 0' into 'bla | 0' (jdk 6)
        engine.eval(new InputStreamReader(getClass().getResourceAsStream("/guru/nidi/raml/doc/static/beautify.js"), "utf-8"));
        engine.eval("jsBeautify=js_beautify;");
        jsBeautifyer = invocable.getInterface(JsBeautifyer.class);

        //marked.js: commented lines 723,727 because of unrecognized unicode chars (jdk 6)
        engine.eval("Inline=null;");
        engine.eval(new InputStreamReader(getClass().getResourceAsStream("/guru/nidi/raml/doc/marked.js"), "utf-8"));
        markdownProcessor = invocable.getInterface(MarkdownProcessor.class);
    } catch (ScriptException | UnsupportedEncodingException e) {
        throw new RuntimeException(e);
    }
}
 

import org.raml.model.Raml; //导入依赖的package包/类
private LoadResults loadRamls() throws IOException {
    final LoadResults res = new LoadResults();
    for (String loc : ramlLocations) {
        try {
            final SavingLoaderInterceptor sli = new SavingLoaderInterceptor();
            final InterceptingLoader loader = new InterceptingLoader(new UriLoader(new FileLoader(new File("."))), sli);
            final Raml raml = new RamlLoad(loader).load(loc);
            new SchemaLoader(raml, loc, loader).loadSchemas();
            sli.raml = raml;
            res.ramls.add(raml);
            res.slis.add(sli);
        } catch (Exception e) {
            throw new IOException("Problem loading RAML from '" + loc + "'", e);
        }
    }
    return res;
}
 

import org.raml.model.Raml; //导入依赖的package包/类
@Override
public String createApi(Raml raml, String name, JSONObject config) {
    this.config = config;

    // TODO: What to use as description?
    final RestApi api = createApi(getApiName(raml, name), null);

    LOG.info("Created API "+api.getId());
    
    try {
        final Resource rootResource = getRootResource(api).get();
        deleteDefaultModels(api);
        createModels(api, raml.getSchemas(), false);
        createResources(api, createResourcePath(api, rootResource, raml.getBasePath()),
                         new HashMap<String, UriParameter>(), raml.getResources(), false);
    } catch (Throwable t) {
        LOG.error("Error creating API, rolling back", t);
        rollback(api);
        throw t;
    }
    return api.getId();
}
 

import org.raml.model.Raml; //导入依赖的package包/类
@Test
public void shouldFlattenResourceList() throws Exception {
    final Raml raml = new Raml();

    final Resource usersResource = new Resource();
    final Resource userResource = new Resource();
    final Resource userSettingsResource = new Resource();

    usersResource.getResources().put("/{userId}", userResource);
    userResource.getResources().put("/settings", userSettingsResource);

    raml.getResources().put("/users", usersResource);

    final List<Resource> flattenned = ResourceList.of(Lists.newArrayList(usersResource))
            .flatten()
            .collect(toList());

    assertThat(flattenned, containsInAnyOrder(usersResource, userResource, userSettingsResource));
}
 

import org.raml.model.Raml; //导入依赖的package包/类
@Override
protected Raml getRaml() {
    try {
        File file = new File(filePath);
        if (!file.exists())
            throw new IllegalArgumentException(String.format("[ %s ] does not exist.", file.getPath()));

        if (file.exists() && !file.canRead())
            throw new IllegalStateException(String.format("[ %s ] cannot be read.", file.getPath()));

        if (file.exists() && !file.isFile())
            throw new IllegalArgumentException(String.format("[ %s ] is not a file.", file.getPath()));

        ResourceLoader loader = new FileResourceLoader(file.getParent());
        return new RamlDocumentBuilder(loader).build(new FileInputStream(file), file.getAbsolutePath());
    } catch (IOException e) {
        throw new RuntimeException(e);
    }
}
 

import org.raml.model.Raml; //导入依赖的package包/类
@Override
public String createApi(Raml raml, String name, JSONObject config) {
    this.config = config;

    // TODO: What to use as description?
    final RestApi api = createApi(getApiName(raml, name), null);

    LOG.info("Created API "+api.getId());
    
    try {
        final Resource rootResource = getRootResource(api).get();
        deleteDefaultModels(api);
        createModels(api, raml.getSchemas(), false);
        createResources(api, createResourcePath(api, rootResource, raml.getBasePath()), raml.getResources(), false);
    } catch (Throwable t) {
        LOG.error("Error creating API, rolling back", t);
        rollback(api);
        throw t;
    }
    return api.getId();
}
 

import org.raml.model.Raml; //导入依赖的package包/类
@Override
public synchronized Object getProperty(Interpreter anInter, ST aSt,
		Object anObject, Object aProperty, String aName)
		throws STNoSuchPropertyException {
	Raml oRoot=(Raml)anObject;
	if(aName.equals("baseUri")) {
		return Resolver.resolve(oRoot.getBaseUri(), oRoot.getBaseUriParameters(), "[BaseUriParameter]");
	}
	if(aName.equals("cleanVersion")) {
		if(oRoot.getVersion()!=null) {
			return Utils.cleanString(oRoot.getVersion());
		} else {
			return null;
		}
	}
	return super.getProperty(anInter, aSt, anObject, aProperty, aName);
}
 

import org.raml.model.Raml; //导入依赖的package包/类
public void run() {
	File[] ramlFiles = this.getRamlFiles();
	if (ramlFiles.length == 0) {
		throw new RuntimeException("There is no RAML file in " + this.configuration.getSourceDirectory().getPath());
	}
	
	Log logger = this.configuration.getLogger();
	for (File ramlFile : ramlFiles) {
		logger.info("------------------------------------------------------------------------");
		logger.info("Validating and Parsing RAML file " + ramlFile.getPath());
		
		ValidationHelper.validateRamlFile(ramlFile);
		Raml raml = RamlHelper.parseModel(ramlFile);
		currentRamlMap = RamlHelper.parseYaml(ramlFile);
		
		for (GeneratorType type : GeneratorType.values()) {
			logger.info("Generate code for " + type.name() + " layer.");
			this.buildCodeGenerator(type, raml).execute();
		}
	}
}
 

import org.raml.model.Raml; //导入依赖的package包/类
@Test
public void testParseModel() {
	Raml raml = RamlHelper.parseModel("src/test/resources/raml_definition.raml");
	
	assertEquals("World Music API", raml.getTitle());
	assertEquals("http://example.api.com/v1", raml.getBaseUri());
	assertEquals("v1", raml.getVersion());
	
	String[] expectedResources = new String[] { "/songs" };
	Object[] resources = raml.getResources().keySet().toArray();
	Arrays.sort(resources);
	
	for (short i = 0; i < expectedResources.length; i++) {
		assertEquals(expectedResources[i], resources[i]);
	}
}
 

import org.raml.model.Raml; //导入依赖的package包/类
@Test
public void testResourceToService() {
	Generator.currentRamlMap = RamlHelper.parseYaml("src/test/resources/raml.yaml");
	Raml raml = RamlHelper.parseModel("src/test/resources/raml.yaml");
	ServiceMeta service = RamlHelper.resourceToService(raml.getResource("/products"));
	
	assertNotNull(service);
	
	assertEquals("/products", service.getUri());
	assertEquals("Products", service.getType());
	assertEquals("Product", service.getGenericType());
	
	assertEquals(2, service.getActions().size());
	
	List<FieldMeta> params = service.getActions().get(0).getParameters();
	assertEquals(3, params.size());
	assertEquals("region", params.get(0).getName());
	assertEquals("java.lang.String", params.get(0).getType());
}
 

import org.raml.model.Raml; //导入依赖的package包/类
/**
 * Generate the raml file from a given controller source file.
 *
 * @param source The controller source file.
 * @param model  The controller model
 * @throws WatchingException If there is a problem while creating the raml file.
 */
@Override
public void controllerParsed(File source, ControllerModel<Raml> model) throws WatchingException {
    Raml raml = new Raml(); //Create a new raml file
    raml.setBaseUri(baseUri); //set the base uri
    raml.setVersion(project().getVersion());

    //Visit the controller model to populate the raml model
    model.accept(controllerVisitor, raml);

    getLog().info("Create raml file for controller " + raml.getTitle());

    try {
        //create the file
        File output = getRamlOutputFile(source);
        FileUtils.write(output, ramlEmitter.dump(raml));
        getLog().info("Created the RAML description for " + source.getName() + " => " + output.getAbsolutePath());
    } catch (IOException ie) {
        throw new WatchingException("Cannot create raml file", source, ie);
    } catch (IllegalArgumentException e) {
        throw new WatchingException("Cannot create Controller Element from", e);
    }
}
 

import org.raml.model.Raml; //导入依赖的package包/类
public JavaFile javaFile(Raml raml, String basePackage) {

        TypeSpec.Builder api = TypeSpec.classBuilder("Api" + capitalize(sanitize(raml.getTitle())))
                .addJavadoc("$L api client\n", raml.getTitle())
                .addJavadoc("Base URI pattern: $L\n", raml.getBaseUri())
                .addField(configField.fieldSpec())
                .addType(configClass.nestedConfSpec())
                .addMethod(MethodSpec.constructorBuilder().addParameter(ClassName.bestGuess(NestedConfigClass.CONFIG_NESTED_STATIC_CLASS_NAME), configField.name())
                        .addStatement("this.$N = $N", configField.name(), configField.name())
                        .addModifiers(PRIVATE)
                        .build())
                .addModifiers(PUBLIC);

        api.addMethod(MethodSpec.methodBuilder(lowerCase(sanitize(raml.getTitle())))
                .addParameter(ClassName.bestGuess(NestedConfigClass.CONFIG_NESTED_STATIC_CLASS_NAME), configField.name())
                .returns(ClassName.bestGuess(api.build().name))
                .addStatement("return new $N($N)", api.build().name, configField.name())
                .addModifiers(PUBLIC, STATIC)
                .build());

        raml.getResources().values().stream().forEach(resource ->
                api.addMethod(
                        baseResource(resource, basePackage, configField.name(), configClass.getBaseSupplField().name())
                ));
        
        return JavaFile.builder(basePackage, api.build()).build();
    }