/**
* Starts the underlying Chameleon instance.
*
* @param root the base directory of the Chameleon.
* @throws java.io.IOException if the chameleon configuration cannot be read.
* @throws org.osgi.framework.BundleException if the chameleon cannot be started.
*/
private void start(File root) throws BundleException, IOException {
ChameleonConfiguration configuration = new ChameleonConfiguration(root);
StringBuilder packages = new StringBuilder();
Packages.junit(packages);
Packages.wisdomtest(packages);
Packages.javaxinject(packages);
Packages.assertj(packages);
Packages.osgihelpers(packages);
configuration.put("org.osgi.framework.system.packages.extra", packages.toString());
chameleon = new Chameleon(configuration);
fixLoggingSystem(root);
chameleon.start();
Stability.waitForStability(chameleon.context());
}
/**
* Searches for the available class names given the text search
*
* @return all the class names found on the current classpath using the given text search filter
*/
public SortedSet<String> findClassNames(String search, Integer limit) {
Map<Package, ClassLoader[]> packageMap =
Packages.getPackageMap(getClassLoaders(), ignorePackages);
return findClassNamesInPackages(search, limit, packageMap);
}
private String[] getPackageNames() {
Packages annotation = this.testClass.getAnnotation(Packages.class);
return (annotation != null ? annotation.value() : EMPTY_STRING_ARRAY);
}
public LispObject execute(LispObject[] args) throws ConditionThrowable {
if (args.length != 10) return error(new WrongNumberOfArgumentsException(this));
final String packageName = args[0].getStringValue();
LispObject nicknames = checkList(args[1]);
// FIXME size is ignored
// LispObject size = args[2];
LispObject shadows = checkList(args[3]);
LispObject shadowingImports = checkList(args[4]);
LispObject use = checkList(args[5]);
LispObject imports = checkList(args[6]);
LispObject interns = checkList(args[7]);
LispObject exports = checkList(args[8]);
// FIXME docString is ignored
// LispObject docString = args[9];
Package pkg = Packages.findPackage(packageName);
if (pkg != null) return pkg;
if (nicknames != NIL) {
LispObject list = nicknames;
while (list != NIL) {
String nick = javaString(list.car());
if (Packages.findPackage(nick) != null) {
return error(new PackageError("A package named " + nick + " already exists."));
}
list = list.cdr();
}
}
pkg = Packages.createPackage(packageName);
while (nicknames != NIL) {
LispObject string = nicknames.car().STRING();
pkg.addNickname(string.getStringValue());
nicknames = nicknames.cdr();
}
while (shadows != NIL) {
String symbolName = shadows.car().getStringValue();
pkg.shadow(symbolName);
shadows = shadows.cdr();
}
while (shadowingImports != NIL) {
LispObject si = shadowingImports.car();
Package otherPkg = coerceToPackage(si.car());
LispObject symbolNames = si.cdr();
while (symbolNames != NIL) {
String symbolName = symbolNames.car().getStringValue();
Symbol sym = otherPkg.findAccessibleSymbol(symbolName);
if (sym != null) pkg.shadowingImport(sym);
else
return error(
new LispError(
symbolName + " not found in package " + otherPkg.getName() + "."));
symbolNames = symbolNames.cdr();
}
shadowingImports = shadowingImports.cdr();
}
while (use != NIL) {
LispObject obj = use.car();
if (obj instanceof Package) pkg.usePackage((Package) obj);
else {
LispObject string = obj.STRING();
Package p = Packages.findPackage(string.getStringValue());
if (p == null)
return error(new LispError(obj.writeToString() + " is not the name of a package."));
pkg.usePackage(p);
}
use = use.cdr();
}
while (imports != NIL) {
LispObject si = imports.car();
Package otherPkg = coerceToPackage(si.car());
LispObject symbolNames = si.cdr();
while (symbolNames != NIL) {
String symbolName = symbolNames.car().getStringValue();
Symbol sym = otherPkg.findAccessibleSymbol(symbolName);
if (sym != null) pkg.importSymbol(sym);
else
return error(
new LispError(
symbolName + " not found in package " + otherPkg.getName() + "."));
symbolNames = symbolNames.cdr();
}
imports = imports.cdr();
}
while (interns != NIL) {
String symbolName = interns.car().getStringValue();
pkg.intern(symbolName);
interns = interns.cdr();
}
while (exports != NIL) {
String symbolName = exports.car().getStringValue();
pkg.export(pkg.intern(symbolName));
exports = exports.cdr();
}
return pkg;
}
public LispObject execute() {
return Packages.listAllPackages();
}
public static void commandRunnerCLI(String[] args) throws Exception {
Options options = new Options();
options.addOption("encodings", true, "baseUrls 's encodings");
options.addOption("baseUrls", true, "baseUrls");
options.addOption("require", true, "require");
options.addOption("excludeReg", true, "excludeReg");
options.addOption("output", true, "output");
options.addOption("v", "version", false, "version");
options.addOption("outputEncoding", true, "outputEncoding");
options.addOption("outputDependency", true, "outputDependency");
options.addOption("fixModuleName", true, "fixModuleName");
// create the command line parser
CommandLineParser parser = new GnuParser();
CommandLine line;
try {
// parse the command line arguments
line = parser.parse(options, args);
} catch (ParseException exp) {
System.out.println("Unexpected exception:" + exp.getMessage());
return;
}
if (line.hasOption("v")) {
System.out.println("KISSY Module Compiler 1.3.1");
return;
}
Main builder = new Main();
Packages packages = builder.getPackages();
String encodingStr = line.getOptionValue("encodings");
if (encodingStr != null) {
packages.setEncodings(encodingStr.split(","));
}
String baseUrlStr = line.getOptionValue("baseUrls");
if (baseUrlStr != null) {
packages.setBaseUrls(baseUrlStr.split(","));
}
String fixModuleName = line.getOptionValue("fixModuleName");
if (fixModuleName != null) {
builder.setFixModuleName(true);
}
builder.setRequire(line.getOptionValue("require"));
String excludeReg = line.getOptionValue("excludeReg");
if (excludeReg != null) {
builder.setExcludePattern(Pattern.compile(excludeReg));
}
builder.setOutput(line.getOptionValue("output"));
String outputEncoding = line.getOptionValue("outputEncoding");
if (outputEncoding != null) {
builder.setOutputEncoding(outputEncoding);
}
builder.setOutputDependency(line.getOptionValue("outputDependency"));
builder.run();
}
/**
* x -> a,b,c : x depends on a,b,c add a,b,c then add x to final code buffer
*
* @param requiredModuleName module name required
*/
private void combineRequire(String requiredModuleName) {
// if css file, do not combine with js files
if (requiredModuleName.endsWith(".css")
||
// conditional loader
requiredModuleName.startsWith("#")) {
this.addDependency(requiredModuleName);
return;
}
// if specify exclude this module, just return
if (excludePattern != null && excludePattern.matcher(requiredModuleName).matches()) {
this.addDependency(requiredModuleName);
return;
}
if (!packages.isModuleExists(requiredModuleName)) {
System.out.println("warning: module not found: " + requiredModuleName);
this.addDependency(requiredModuleName);
return;
}
Module requiredModule = packages.getModuleFromName(requiredModuleName);
if (requiredModule == null) {
System.err.println("error: invalid module: " + requiredModuleName);
System.exit(1);
}
// x -> a,b,c
// a -> b
// reduce redundant parse and recursive
if (processedModules.contains(requiredModule)) {
return;
}
if (modulesVisited.contains(requiredModuleName)) {
String error =
"cyclic dependence: "
+ ArrayUtils.join(modulesVisited.toArray(new String[modulesVisited.size()]), ",")
+ ","
+ requiredModuleName;
// if silence ,just return
System.err.println(error);
System.exit(1);
return;
}
// mark as start for cyclic detection
modulesVisited.add(requiredModuleName);
requiredModule.completeModuleName(fixModuleName);
String[] requires = requiredModule.getRequires();
for (String require : requires) {
combineRequire(require);
}
// remove mark for cyclic detection
modulesVisited.remove(modulesVisited.size() - 1);
processedModules.add(requiredModule);
}
