com.incapture.rapgen.parser.SampleCodeParser Maven / Gradle / Ivy
/**
* The MIT License (MIT)
*
* Copyright (c) 2011-2016 Incapture Technologies LLC
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
package com.incapture.rapgen.parser;
import japa.parser.JavaParser;
import japa.parser.ParseException;
import japa.parser.ast.CompilationUnit;
import japa.parser.ast.body.MethodDeclaration;
import japa.parser.ast.expr.AnnotationExpr;
import japa.parser.ast.expr.MemberValuePair;
import japa.parser.ast.expr.NormalAnnotationExpr;
import japa.parser.ast.visitor.VoidVisitorAdapter;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import org.apache.commons.collections.CollectionUtils;
import org.apache.commons.io.FileUtils;
import org.apache.commons.lang3.StringUtils;
import org.apache.log4j.Logger;
import rapture.common.annotations.SampleCode;
import com.google.common.collect.HashBasedTable;
import com.google.common.collect.Table;
/**
* Given a set of sourcePaths, parse all the *.type files and find the functions that have our custom {@literal @}SampleCode annotation. Provides a
* getSampleCode function to get the source code, if given the type, api name, and function name.
*
* Example usage:
*
*
* {
* @code
* SampleCodeParser p = new SampleCodeParser();
* p.addSourcePath(SampleCodeParser.SourceType.java, "/path/to/java/srcfiles");
* p.parse();
* String sampleCode = p.getSampleCode(SampleCodeParser.SourceType.java, "doc", "getContent");
* }
*
*
* @author dukenguyen
*
*/
public class SampleCodeParser {
private static final Logger log = Logger.getLogger(SampleCodeParser.class);
private Map sourcePaths = new HashMap<>();
private Table cache = HashBasedTable.create();
public enum SourceType {
java, py
};
/**
* Load a sourcePath and its corresponding source code type for parsing later on.
*
* @param type
* Must be one of the SampleCodeParser.SourceType enumerated values. Specifies the extension of the files to search as well as how to process
* them.
* @param sourcePath
* A folder on the filesystem to search for *.type files to find the annotated functions
*/
public void addSourcePath(SourceType type, String sourcePath) {
if (StringUtils.isBlank(sourcePath) || type == null) {
return;
}
sourcePaths.put(sourcePath, type);
}
/**
* Remove a sourcePath from the pre-loaded paths. This path will not be parsed after successful removal.
*
* @param sourcePath
* the sourcePath to remove
*/
public void removeSourcePath(String sourcePath) {
sourcePaths.remove(sourcePath);
}
/**
* Get the source code for the given type, api, and function name
*
* @param type
* Must be one of the enumerated values in SampleCodeParser.SourceType
* @param api
* API name e.g. doc, structured, series, sheet
* @param functionName
* The name of the function e.g. getContent
* @return String representing the body of the associated function that was annotated with {@literal @}SampleCode, or null if not found
*/
public String getSampleCode(SourceType type, String api, String functionName) {
if (type == null) {
return null;
}
return cache.get(getCacheRowKey(type, api), functionName);
}
/**
* Parse all the pre-loaded sourcePaths for all *.type files that have a {@literal @}SampleCode annotated function.
*
* @throws SampleCodeParserException
* if there was a problem parsing the source
*/
public void parse() throws SampleCodeParserException {
cache.clear();
for (Map.Entry entry : sourcePaths.entrySet()) {
Collection files = FileUtils.listFiles(new File(entry.getKey()), new String[] { entry.getValue().name() }, true);
switch (entry.getValue()) {
case java:
for (File file : files) {
FileInputStream in = null;
CompilationUnit cu = null;
try {
in = new FileInputStream(file);
cu = JavaParser.parse(in);
} catch (ParseException | FileNotFoundException e) {
throw new SampleCodeParserException(e);
} finally {
if (in != null) {
try {
in.close();
} catch (IOException e) {
log.warn("Failed to close FileInputStream for file: " + e.toString());
}
}
}
new MethodVisitor<>(entry.getValue()).visit(cu, cache);
}
break;
case py:
break;
}
}
}
private class MethodVisitor> extends VoidVisitorAdapter {
private SourceType type;
public MethodVisitor(SourceType type) {
this.type = type;
}
@Override
public void visit(MethodDeclaration method, A result) {
if (CollectionUtils.isEmpty(method.getAnnotations())) {
return;
}
for (AnnotationExpr annotation : method.getAnnotations()) {
if (!annotation.getClass().equals(NormalAnnotationExpr.class)) {
continue;
}
NormalAnnotationExpr annot = (NormalAnnotationExpr) annotation;
if (annot.getName().toString().equals(SampleCode.class.getSimpleName())
&& !CollectionUtils.isEmpty(annot.getPairs())) {
for (MemberValuePair pair : annot.getPairs()) {
// get the 'api' parameter from the annotation to let us know which api this function belongs to
if (StringUtils.equals(pair.getName(), "api") && !StringUtils.isBlank(pair.getValue().toString())) {
result.put(getCacheRowKey(type, pair.getValue().toString().replace("\"", "")), stripTestPrefix(method.getName()),
stripCurlyBrackets(method.getBody().toString()));
return;
}
}
}
}
}
}
/**
* Strip leading 'test' from any function names and apply proper capitalization
*
* @param functionName
* The function to be adjusted
* @return functionName without leading 'test' and proper capitalization
*/
String stripTestPrefix(String functionName) {
if (StringUtils.isBlank(functionName)) {
return null;
}
if (StringUtils.startsWithIgnoreCase(functionName, "test")) {
return StringUtils.uncapitalize(functionName.substring(4));
}
return functionName;
}
/**
* Remove leading and trailing curly brackets from source code
*
* @param sourceCode
* The source code to be modified
* @return sourceCode with leading and trailing curly bracket removed
*/
String stripCurlyBrackets(String sourceCode) {
if (StringUtils.isBlank(sourceCode)) {
return null;
}
String ret = sourceCode.trim();
if (ret.startsWith("{")) {
ret = ret.substring(1);
}
if (ret.endsWith("}")) {
ret = ret.substring(0, ret.length() - 1);
}
return ret;
}
private String getCacheRowKey(SourceType type, String api) {
return String.format("%s.%s", type.name(), api);
}
} © 2015 - 2025 Weber Informatics LLC | Privacy Policy