/** ** Reads/returns the specified CompileTime template file */
private static String readTemplate(File tf, String pkgName) {
/* read template data */
byte templData[] = FileTools.readFile(tf);
if (templData == null) {
Print.errPrintln("\nUnable to read Input/Template file: " + tf);
return null;
} else if (templData.length == 0) {
Print.errPrintln("\nInput/Template file is empty: " + tf);
return null;
}
/* return template String */
String templateText = StringTools.toStringValue(templData);
if (!StringTools.isBlank(pkgName) && !StringTools.isBlank(templateText)) {
String lines[] = StringTools.split(templateText, '\n', false);
for (int i = 0; i < lines.length; i++) {
if (lines[i].trim().startsWith(JAVA_PACKAGE_)) {
lines[i] = CompiletimeVars.packageLine(pkgName);
return StringTools.join(lines, '\n') + "\n";
}
}
StringBuffer sb = new StringBuffer();
sb.append(CompiletimeVars.packageLine(pkgName)).append("\n");
sb.append(templateText);
return sb.toString();
} else {
return templateText;
}
}
/** ** Apply replacements/conditionals and write output */
public static void writeOutputSource(String inputSource, File outputFile) throws IOException {
String outputSource = inputSource;
if (StringTools.isBlank(outputSource)) {
// throw new IOException("Output Source is empty");
return;
}
/* custom map */
Map<String, String> customMap =
new HashMap<String, String>() {
@Override
public String get(Object key) {
String ks = StringTools.trim(key);
if (ks.toLowerCase().endsWith(".md5")) {
String K = ks.substring(0, ks.length() - ".md5".length());
String V = RTConfig._getString(K, null, true /*dftOK*/);
if (V != null) {
return StringTools.trim(FileTools.getHash_MD5(V.getBytes())).toUpperCase();
} else {
return null;
}
} else {
return null;
}
}
};
/* replace standard runtime vars in text (ie. %{var=value}) */
// -- replace %{var=value}
outputSource =
RTConfig.insertKeyValues(outputSource, STR_DELIM, END_DELIM, DFT_DELIM, customMap);
// -- replace /#{var=value}#/
outputSource =
RTConfig.insertKeyValues(outputSource, STR_CDELIM, END_CDELIM, DFT_CDELIM, customMap);
/* conditional code? */
outputSource = CompiletimeVars.getConditionalSource(outputSource);
/* write output */
if (outputFile != null) {
Print.sysPrintln("Output to file: " + outputFile);
boolean didWrite = FileTools.writeFile(outputSource.getBytes(), outputFile);
if (!didWrite) {
throw new IOException("Unable to write output file.");
}
} else {
// -- write to stdout
Print.sysPrintln(outputSource);
}
}
/** ** Main entry point for testing/debugging ** @param argv Comand-line arguments */
public static void main(String argv[]) {
RTConfig.setCommandLineArgs(argv);
/* help */
if (RTConfig.hasProperty(ARG_HELP)) {
_usage();
System.exit(1); // control does not reach here
}
/* extra args */
String extraArgs = RTConfig.getString(ARG_EXTRA, "");
if (!StringTools.isBlank(extraArgs)) {
// Print.logInfo("Extra: " + extraArgs);
RTProperties cfgProps = RTConfig.getConfigFileProperties();
if (extraArgs.indexOf(",") > 0) {
cfgProps.setProperties(extraArgs, ',');
} else {
cfgProps.setProperties(extraArgs);
}
// cfgProps.printProperties("");
}
/* special case "expire" */
String ARG_EXPIRE = "expire";
RTProperties expireRTP = RTConfig.getPropertiesForKey(ARG_EXPIRE, false);
if (expireRTP != null) {
Print.errPrintln("\n'expire' cannot be defined.");
System.exit(1);
}
/* args */
File directory = RTConfig.getFile(ARG_DIR, null);
String templateName =
StringTools.trim(RTConfig.getString(ARG_OPTIONAL, RTConfig.getString(ARG_TEMPLATE, "")));
boolean isOptional = RTConfig.hasProperty(ARG_OPTIONAL);
String packageName = StringTools.trim(RTConfig.getString(ARG_PACKAGE, null));
String outputName = RTConfig.getString(ARG_OUTPUT, "");
boolean overwrite = RTConfig.getBoolean(ARG_OVERWRITE, false);
/* cannot specify "-output=inline" if internal template specified */
if (StringTools.isBlank(outputName) || outputName.equalsIgnoreCase("stdout")) {
// -- output will be to "stdout"
outputName = "";
} else if (outputName.equalsIgnoreCase("inline")) {
// -- output will be to input file
if (templateName.startsWith(TEMPLATE_)) {
// -- @template not allowed with "inline"
Print.errPrintln("\nError: Cannot specify '-output=inline' with internal template");
_usage();
System.exit(1); // control does not reach here
} else if (isOptional) {
// -- optional not allowed with "inline"
Print.errPrintln("\nError: Cannot specify '-output=inline' with optional template");
_usage();
System.exit(1); // control does not reach here
} else if (!templateName.startsWith("*")) {
// -- output to input file
outputName = templateName;
}
} else {
// -- output to specified file
if (templateName.startsWith("*")) {
// -- template specifies a file-glob
Print.errPrintln(
"\nError: Cannot specify '-output=FILE' for recursize template specification");
_usage();
System.exit(1); // control does not reach here
}
}
/* template name file? */
if (templateName.startsWith("*")) {
if (isOptional) {
// -- optional not allowed with glob file specification
Print.errPrintln("\nError: Cannot specify optional '-template?=[**/]*.java'");
_usage();
System.exit(1); // control does not reach here
}
} else {
File file = (directory != null) ? new File(directory, templateName) : new File(templateName);
if (!file.isFile() && isOptional) {
// -- templateName doesn't exist and is optional
templateName = TEMPLATE_DEFAULT;
}
}
/* random */
Random rand = new Random();
if (!RTConfig.hasProperty("random.16")) {
RTConfig.setString("random.16", "0x" + StringTools.toHexString(rand.nextInt() & 0xFFFF, 16));
}
if (!RTConfig.hasProperty("random.32")) {
RTConfig.setString("random.32", "0x" + StringTools.toHexString(rand.nextInt(), 32));
}
if (!RTConfig.hasProperty("random.64")) {
RTConfig.setString("random.64", "0x" + StringTools.toHexString(rand.nextLong(), 64));
}
/* set current time (subject to change) */
String tzStr = RTConfig.getString("timezone", null);
TimeZone tz =
!StringTools.isBlank(tzStr) ? DateTime.getTimeZone(tzStr) : DateTime.getDefaultTimeZone();
DateTime now = new DateTime(tz);
if (!RTConfig.hasProperty("timetamp")) {
RTConfig.setLong("timestamp", now.getTimeSec());
}
if (!RTConfig.hasProperty("datetime")) {
RTConfig.setString("datetime", now.format("yyyy/MM/dd HH:mm:ss z"));
}
if (!RTConfig.hasProperty("date")) {
RTConfig.setString("date", now.format("yyyy/MM/dd"));
}
if (!RTConfig.hasProperty("time")) {
RTConfig.setString("time", now.format("HH:mm:ss"));
}
if (!RTConfig.hasProperty("timezone")) {
RTConfig.setString("timezone", now.format("z"));
}
/* special case "daysUntil" */
// %{daysUntil=2012:02:20} <== fixed time
String ARG_daysUntil_ = "daysUntil";
Set<String> daysUntil_keys = RTConfig.getPropertyKeys(ARG_daysUntil_, false);
for (String daysUntil_key : daysUntil_keys) {
String daysUntil_key_date = daysUntil_key + ".date";
RTProperties daysUntilRTP = RTConfig.getPropertiesForKey(daysUntil_key, false);
if (daysUntilRTP != null) {
// -- get/update the RTProperties where "daysUntil" is defined
String daysUntil = daysUntilRTP.getString(daysUntil_key, "");
if (StringTools.isBlank(daysUntil)) {
// -- remove keys
daysUntilRTP.removeProperty(daysUntil_key);
daysUntilRTP.removeProperty(daysUntil_key_date);
// Print.sysPrintln(daysUntil_key + " ==> <removed>");
// Print.sysPrintln(daysUntil_key_date + " ==> <removed>");
} else if ((daysUntil.indexOf("/") >= 0) || (daysUntil.indexOf(":") >= 0)) {
// -- Change "yyyy:mm:dd" to "DD"
// Note: The ':' separator should be used instead of '/', because "2010/10/01" is
// syntactically correct (ie. division) and can be compiled into a valid value,
// while "2010:10:01" is not, and will be caught by the compiler.
if (daysUntil.startsWith("'") || daysUntil.startsWith("\"")) {
daysUntil = daysUntil.substring(1); // remove prefixing quote
}
if (daysUntil.endsWith("'") || daysUntil.endsWith("\"")) {
daysUntil = daysUntil.substring(0, daysUntil.length() - 1); // remove trailing quote
}
try {
DateTime nowDT = new DateTime(DateTime.getGMTTimeZone());
DateTime futDT = DateTime.parseArgumentDate(daysUntil, null, true);
long nowDay = DateTime.getDayNumberFromDate(nowDT);
long futDay = DateTime.getDayNumberFromDate(futDT);
long deltaD = futDay - nowDay;
if (deltaD == 0L) {
// -- today
deltaD = 1L; // make it tomorrow
} else if (deltaD < 0L) {
// -- this means that the date has already passed
// deltaD = -1L; // already negative
} else {
deltaD += 1L; // add one more day
}
daysUntilRTP.setString(daysUntil_key, String.valueOf(deltaD));
daysUntilRTP.setString(daysUntil_key_date, futDT.format(DateTime.DEFAULT_DATE_FORMAT));
} catch (DateTime.DateParseException dpe) {
Print.logException("Unable to parse Date: " + daysUntil, dpe);
System.exit(1);
}
// Print.sysPrintln(daysUntil_key + " ==> " + daysUntilRTP.getString(daysUntil_key
// ,"?"));
// Print.sysPrintln(daysUntil_key_date + " ==> " +
// daysUntilRTP.getString(daysUntil_key_date,"?"));
} else {
long futSec =
DateTime.getCurrentTimeSec()
+ DateTime.DaySeconds(StringTools.parseLong(daysUntil, 0L));
daysUntilRTP.setString(
daysUntil_key_date, (new DateTime(futSec)).format(DateTime.DEFAULT_DATE_FORMAT));
// Print.sysPrintln(daysUntil_key + " ==> " + daysUntilRTP.getString(daysUntil_key
// ,"?"));
// Print.sysPrintln(daysUntil_key_date + " ==> " +
// daysUntilRTP.getString(daysUntil_key_date,"?"));
}
}
}
/* special case "daysFromNow" */
// %{daysFromNow=30} <== 30 days from now
String ARG_daysFromNow_ = "daysFromNow";
Set<String> daysFromNow_keys = RTConfig.getPropertyKeys(ARG_daysFromNow_, false);
for (String daysFromNow_key : daysFromNow_keys) {
String daysFromNow_key_date = daysFromNow_key + ".date";
RTProperties daysFromNowRTP = RTConfig.getPropertiesForKey(daysFromNow_key, false);
if (daysFromNowRTP != null) {
// -- get/update the RTProperties where "daysFromNow" is defined
String daysFromNow = daysFromNowRTP.getString(daysFromNow_key, "");
if (StringTools.isBlank(daysFromNow)) {
// -- remove keys
daysFromNowRTP.removeProperty(daysFromNow_key);
daysFromNowRTP.removeProperty(daysFromNow_key_date);
// Print.sysPrintln(daysFromNow_key + " ==> <removed>");
// Print.sysPrintln(daysFromNow_key_date + " ==> <removed>");
} else {
long futSec =
DateTime.getCurrentTimeSec()
+ DateTime.DaySeconds(StringTools.parseLong(daysFromNow, 0L));
daysFromNowRTP.setString(daysFromNow_key, String.valueOf(futSec));
daysFromNowRTP.setString(
daysFromNow_key_date, (new DateTime(futSec)).format(DateTime.DEFAULT_DATE_FORMAT));
// Print.sysPrintln(daysFromNow_key + " ==> " +
// daysFromNowRTP.getString(daysFromNow_key ,"?"));
// Print.sysPrintln(daysFromNow_key_date + " ==> " +
// daysFromNowRTP.getString(daysFromNow_key_date,"?"));
}
}
}
/* special case "secondsUntil" */
// %{secondsUntil_abc=2012:02:20} <== fixed time
// %{secondsUntil_abc=86400} <== relative time (86400 seconds from now)
String ARG_secondsUntil_ = "secondsUntil";
Set<String> secUntil_keys = RTConfig.getPropertyKeys(ARG_secondsUntil_, false);
for (String secUntil_key : secUntil_keys) {
String secUntil_key_date = secUntil_key + ".date";
RTProperties secUntilRTP = RTConfig.getPropertiesForKey(secUntil_key, false);
if (secUntilRTP != null) {
// -- get/update the RTProperties where "secondsUntil" is defined
String secUntil = secUntilRTP.getString(secUntil_key, "");
if (StringTools.isBlank(secUntil)) {
// remove keys
secUntilRTP.removeProperty(secUntil_key);
secUntilRTP.removeProperty(secUntil_key_date);
// Print.sysPrintln(secUntil_key + " ==> <removed>");
// Print.sysPrintln(secUntil_key_date + " ==> <removed>");
} else if ((secUntil.indexOf("/") >= 0) || (secUntil.indexOf(":") >= 0)) {
// -- Change "yyyy:mm:dd:HH:MM:SS" to "ssssss"
// Note: The ':' separator should be used instead of '/', because "2010/10/01" is
// syntactically correct (ie. division) and can be compiled into a valid value,
// while "2010:10:01" is not, and will be caught by the compiler.
if (secUntil.startsWith("'") || secUntil.startsWith("\"")) {
secUntil = secUntil.substring(1); // remove prefixing quote
}
if (secUntil.endsWith("'") || secUntil.endsWith("\"")) {
secUntil = secUntil.substring(0, secUntil.length() - 1); // remove trailing quote
}
try {
long nowSec = DateTime.getCurrentTimeSec();
DateTime futDT = DateTime.parseArgumentDate(secUntil, null, true);
long futSec = futDT.getTimeSec();
long deltaS = futSec - nowSec;
if (deltaS == 0L) {
// -- now
deltaS = 1L; // make it 1 second from now
} else if (deltaS < 0L) {
// -- this means that the time has already passed
// deltaS = -1L; // already negative
} else {
deltaS += 1L; // add one more second
}
secUntilRTP.setString(secUntil_key, String.valueOf(deltaS));
secUntilRTP.setString(secUntil_key_date, futDT.toString());
} catch (DateTime.DateParseException dpe) {
Print.logException("Unable to parse Date: " + secUntil, dpe);
System.exit(1);
}
// Print.sysPrintln(secUntil_key + " ==> " + secUntilRTP.getString(secUntil_key
// ,"?"));
// Print.sysPrintln(secUntil_key_date + " ==> " +
// secUntilRTP.getString(secUntil_key_date,"?"));
} else {
long futSec = DateTime.getCurrentTimeSec() + StringTools.parseLong(secUntil, 0L);
secUntilRTP.setString(secUntil_key_date, (new DateTime(futSec)).toString());
// Print.sysPrintln(secUntil_key + " ==> " + secUntilRTP.getString(secUntil_key
// ,"?"));
// Print.sysPrintln(secUntil_key_date + " ==> " +
// secUntilRTP.getString(secUntil_key_date,"?"));
}
}
}
/* special case "secondsFromNow" */
// %{secondsFromNow=30} <== 30 seconds from now
String ARG_secondsFromNow_ = "secondsFromNow";
Set<String> secondsFromNow_keys = RTConfig.getPropertyKeys(ARG_secondsFromNow_, false);
for (String secondsFromNow_key : secondsFromNow_keys) {
String secondsFromNow_key_date = secondsFromNow_key + ".date";
RTProperties secondsFromNowRTP = RTConfig.getPropertiesForKey(secondsFromNow_key, false);
if (secondsFromNowRTP != null) {
// -- get/update the RTProperties where "secondsFromNow" is defined
String secondsFromNow = secondsFromNowRTP.getString(secondsFromNow_key, "");
if (StringTools.isBlank(secondsFromNow)) {
// -- remove keys
secondsFromNowRTP.removeProperty(secondsFromNow_key);
secondsFromNowRTP.removeProperty(secondsFromNow_key_date);
// Print.sysPrintln(secondsFromNow_key + " ==> <removed>");
// Print.sysPrintln(secondsFromNow_key_date + " ==> <removed>");
} else {
long futSec = DateTime.getCurrentTimeSec() + StringTools.parseLong(secondsFromNow, 0L);
secondsFromNowRTP.setString(secondsFromNow_key, String.valueOf(futSec));
secondsFromNowRTP.setString(
secondsFromNow_key_date, (new DateTime(futSec)).format(DateTime.DEFAULT_DATE_FORMAT));
// Print.sysPrintln(secondsFromNow_key + " ==> " +
// secondsFromNowRTP.getString(secondsFromNow_key ,"?"));
// Print.sysPrintln(secondsFromNow_key_date + " ==> " +
// secondsFromNowRTP.getString(secondsFromNow_key_date,"?"));
}
}
}
/* special case "limit" */
String ARG_limit_ = "limit";
Set<String> limit_keys = RTConfig.getPropertyKeys(ARG_limit_, false);
for (String limit_key : limit_keys) {
RTProperties limitRTP = RTConfig.getPropertiesForKey(limit_key, false);
if (limitRTP != null) {
String limit = limitRTP.getString(limit_key, "");
if (StringTools.isBlank(limit)) {
limitRTP.removeProperty(limit_key);
// Print.sysPrintln(limit_key + " ==> <removed>");
} else {
// Print.sysPrintln(limit_key + " ==> " + limit);
}
}
}
/* adjust packageName */
if (packageName.equals(JAVA_PACKAGE)) {
Print.errPrintln(
"\nWarning: 'package' argument cannot equal \"package\" (setting to empty string).");
packageName = "";
}
// --------------------------------------
/* internal template (single pass only) */
if (StringTools.isBlank(templateName) || templateName.startsWith(TEMPLATE_)) {
try {
// -- input source
String inputSource = standardTemplate(templateName, packageName);
if (StringTools.isBlank(inputSource)) {
if (isOptional) {
// -- optional "templateName" not defined, use default template
inputSource = standardTemplate(null, packageName); // non-blank
} else {
throw new IOException("Standard template not found: " + templateName);
}
}
// -- write template output
File outputFile = CompiletimeVars.getOutputFile(directory, outputName, overwrite);
CompiletimeVars.writeOutputSource(inputSource, outputFile);
} catch (NoOverwriteException noe) {
// -- outputFile exists, quietly ignore
Print.sysPrintln(noe.getMessage());
System.exit(0);
} catch (IOException ioe) {
// -- error writin file
Print.errPrintln("\nError writing template: " + ioe.getMessage());
System.exit(1);
}
System.exit(0);
}
// --------------------------------------
/* get input file(s) */
File inputFileArray[] = null;
if (templateName.startsWith("**/*.")) {
// -- all files, in all directories (recursive)
String fileGlob = templateName.substring(3);
File files[] = FileTools.getFiles(directory, fileGlob, true);
inputFileArray = files;
} else if (templateName.startsWith("*.")) {
// -- all files in specified directory
String fileGlob = templateName;
File files[] = FileTools.getFiles(directory, fileGlob, false);
inputFileArray = files;
} else {
// -- single specific file
File file = (directory != null) ? new File(directory, templateName) : new File(templateName);
inputFileArray = new File[] {file};
}
/* loop through input files */
boolean singlePass = false;
for (File inputFile : inputFileArray) {
/* file must exist here */
if (!inputFile.isFile()) {
// -- not a file
continue;
}
/* get input source from template file */
String inputSource = CompiletimeVars.readTemplate(inputFile, packageName);
if (StringTools.isBlank(inputSource)) {
// -- inputSource not available?
continue;
}
/* precheck output file */
File outputFile = null;
try {
if (StringTools.isBlank(outputName) || outputName.equalsIgnoreCase("stdout")) {
// -- output to stdout (multi-pass ok)
} else if (outputName.equalsIgnoreCase("inline")) {
// -- write back to template file (multi-pass ok)
overwrite = true; // assume implied overwrite
outputFile = inputFile;
} else {
// -- output to specified file (single-pass only)
outputFile = getOutputFile(directory, outputName, overwrite);
singlePass = true;
}
} catch (NoOverwriteException noe) {
// -- outputFile exists, quietly ignore
Print.sysPrintln(noe.getMessage());
System.exit(0);
} catch (IOException ioe) {
Print.errPrintln("\nInvalid output file: " + ioe.getMessage());
System.exit(1);
}
/* adjust source and write output */
try {
CompiletimeVars.writeOutputSource(inputSource, outputFile);
if (singlePass) {
break;
}
} catch (IOException ioe) {
Print.errPrintln("\nError writing file: " + ioe.getMessage());
System.exit(1);
}
}
/* success */
System.exit(0);
}