Пример #1
0
 /**
  * ** Gets args as RTProperties instance ** @return A new RTProperties instance with this URIArg's
  * key value pairs
  */
 public RTProperties getArgProperties() {
   RTProperties rtp = new RTProperties();
   for (Iterator i = this.getKeyValList().iterator(); i.hasNext(); ) {
     KeyVal kv = (KeyVal) i.next();
     rtp.setString(kv.getKey(), this.decodeArg(kv.getValue()));
   }
   return rtp;
 }
Пример #2
0
 /**
  * ** Returns a new URIArg with this URIArg's arguments encoded into a ** single RTProperties
  * added with a specified key [CHECK] ** @param rtpKey The key to add the encoded args at
  * ** @param exclKeys keys to exclude from encoding ** @return A new URIArg with non excluded
  * arguments encoded
  */
 public URIArg rtpEncode(String rtpKey, String... exclKeys) {
   URIArg rtpUrl = new URIArg(this.getURI());
   RTProperties rtp = new RTProperties();
   for (KeyVal kv : this.getKeyValList()) {
     String kn = kv.getKey();
     if (ListTools.contains(exclKeys, kn)) {
       rtpUrl.addArg(kv);
     } else {
       rtp.setString(kn, kv.getValue());
     }
   }
   rtpUrl.addArg(rtpKey, rtp);
   return rtpUrl;
 }
  /** ** 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);
  }