/*----------------------------------------------------------------

  * $Id: Script.java,v 1.1.1.1 2005/06/08 02:40:48 pkb Exp $

  * 

  * (c)2001 - Paul Blankenbaker */

 //----------------------------------------------------------------

 package com.ccg.macros.at;

 import com.ccg.macros.*;

 import com.ccg.io.*;

 import com.ccg.util.*;

 import java.io.*;

 import java.util.Vector;

 //----------------------------------------------------------------

 /** <b>&#064;macros</b> useful for "script" style processing.

  * 

  * @version $Revision: 1.1.1.1 $

  * 

  * @since 1.0

  * 

  * @author $Author: pkb $ */

 //----------------------------------------------------------------

 public class Script extends Base {

   //----------------------------------------------------------------

   /** Constructs the object and readies it for {@link #install installation}.

    * 

    * @since        1.0

    * 

    * @see #install */

   //----------------------------------------------------------------

   public Script() {

     super(false);

   }

   //----------------------------------------------------------------

   /** @loadTSV(NAME,SOURCE) load a tab separated table.

    * 

    * <p>This macro is used to load the definition of a tab separated

    * table. It doesn't actually read the contents of the database

    * immediately, instead it defines a new macro named "NAME" and

    * associates a SOURCE (typically a file or URL) where we should

    * fetch the data from.

    *

    * <p>When you want to insert the data of the table into your

    * output, you then use the "@NAME(FORMAT)" macro to read each line

    * from the table and FORMAT the output of the table.

    *

    * <p>For example, if one created a table named {@link

    * <a href=doc-files/phone.tsv>phone.tsv</a>} like the following:

    *

 <pre>

 Last        First        Phone

 Blankenbaker        Paul        555-555-5555

 Brown        Megan        555-555-5555

 </pre>

    *

    * <p>And you used the following macros:

    *

    * <pre>

    * &#064;loadTSV("phoneTable","{@link <a href=doc-files/phone.tsv>phone.tsv</a>}")

    * @phoneTable("@phoneTableF(1),@phoneTableF(0),@phoneTableF(2)\n")

    * </pre>

    *

    * <p>This will result in the output of one blank line followed by a

    * comma seaparated list of just the data fields. This is shown below:

    *

    * <pre>

    *

    * Paul,Blankenbaker,555-555-5555

    * Megan,Brown,555-555-5555

    * </pre>

    *

    * <p>In the example, you'll notice that the macro used to process

    * the table was called <b>&#064;phoneTable</b>. When we used this

    * macro, we accessed the specific columns within the table using a

    * new macro <b>&#064;phoneTableF(COL)</b>. This macro is defined

    * while processing each row of the table and allows one to access

    * the column fields within a row of the table. You can specify the

    * column either by its number (where 0 is the left most column), or

    * it column heading. Using column headings to pull information from

    * the table, we would have written the following:

    *

    * <pre>

    * &#064;loadTSV("phoneTable","{@link <a href=doc-files/phone.tsv>phone.tsv</a>}")

    * @phoneTable("@phoneTableF("First"),@phoneTableF("Last"),@phoneTableF("Phone")\n")

    * </pre>

    *

    * <p>If you are producing HTML, you can use the table formatting

    * tags to nicely format your table data.

    * 

    * @param        out

    * 

    *         The {@link Output output device} to write the results of

    *         processing the argument to.

    * 

    * @param        args

    * 

    *         A {@link Vector vector} of arguments which were passed to the macro.

    * 

    * @throws        IOException

    * 

    *         If there is a problem writing to the {@link Output output device}

    * 

    * @throws        InterpretException

    * 

    *         If a problem is encountered interpretting the arguments passed.

    * 

    * @since        1.0 */

   //----------------------------------------------------------------

   public void loadTSV(Output out, Vector args) 

     throws IOException, InterpretException {

     if (args.size() < 2) {

       throw new InterpretException("@loadTSV(NAME,SOURCE) requires "+

                                    "two arguments.");

     }

     AtMacros am = getAtMacros();

     String name = am.interpretCheck(args.elementAt(0).toString());

     String source = am.interpretCheck(args.elementAt(1).toString());

     if ((name == null) || (source == null) ||

         (name.length() == 0) || (source.length() == 0)) {

       throw new InterpretException("null argument passed to "+

                                    "@loadTSV(NAME,SOURCE)");

     }

     am.addMacro(name,new TableInsert(am,name,source));

   }

   //----------------------------------------------------------------

   /** @copyToDir(MATCH0,MATCH1,...,DIR) copy one or

    * more files to directory.

    * 

    * <p>This macro is used to copy 0 or more existing files to a

    * output directory. If the directory doesn't exist, it will be

    * created. You may use the "*" as a wildcard in each of the file

    * name strings to match more than one file.

    *

    * <p>For example, to copy the ".at" and "*.properties" files from

    * the "/etc/macros" directory to the "/home/user/etc/macros"

    * directory, one could use the following:

    *

 <pre>

 @defnow("sdir","/etc/macros")

 @copyToDir("@sdir()/*.at","@sdir()/*.properties","/home/user/etc/macros")

 </pre>

    *

    * @param        out

    * 

    *         The {@link Output output device} to write the results of

    *         processing the argument to.

    * 

    * @param        args

    * 

    *         A {@link Vector vector} of arguments which were passed to the macro.

    * 

    * @throws        IOException

    * 

    *         If there is a problem writing to the {@link Output output device}

    * 

    * @throws        InterpretException

    * 

    *         If a problem is encountered interpretting the arguments passed.

    * 

    * @since        1.0 */

   //----------------------------------------------------------------

   public void copyToDir(Output out, Vector args) 

     throws IOException, InterpretException {

     int argc = args.size();

     if (argc < 2) return;        // must have at least two arguments

     argc--;                        // last argument is the output directory

                                 // get output directory

     AtMacros am = getAtMacros();

     String dstStr = am.interpretCheck(args.elementAt(argc).toString());

     File dst = new File(FileName.fixSlashes(dstStr));

                                 // try to create directory - if it

                                 // doesn't exist

     if (!dst.isDirectory()) {

       dst.mkdirs();

       if (!dst.isDirectory()) {

         throw new IOException("unable to create directory \""+dst+"\"");

       }

     }

     PrintWriterString pws = PrintWriterString.create();

                                 // now, process each of the wild-card

                                 // file name strings

     for (int i = 0; i < argc; i++) {

       String match = am.interpretCheck(args.elementAt(i).toString());

       String[] list = FilenameFilterWild.list(FileName.fixSlashes(match));

       if (list != null) for (int j = 0; j < list.length; j++) {

         File src = new File(list[j]);

                                 // only copy existing normal files

         if (src.exists() && src.isFile()) {

           File ofile = new File(dst,src.getName());

           pws.print("Copy:");

           pws.print(src);

           pws.print("  to:");

           pws.println(dst);

           Copy.fileToFile(src,ofile);

         }

         else if (Debug.ENABLED && Debug.isEnabledFor(3)) {

           pws.print("Skip:");

           pws.println(src);

         }

       }

     }

     out.write(pws);

   }

   //----------------------------------------------------------------

   /** @atCopyToDir(MATCH0,MATCH1,...,DIR) copy AND

    * interpret one or more files to directory.

    * 

    * <p>This macro is used to copy 0 or more existing files to a

    * output directory. If the directory doesn't exist, it will be

    * created. You may use the "*" as a wildcard in each of the file

    * name strings to match more than one file.

    *

    * <p>There is a HUGE difference between this command and the

    * "@copyToDir". This command interprets each file that it

    * copies and evaluates any "&#064macros" which it contains. This

    * can be a VERY useful way to install HTML documents to their final

    * location and do some subsitutions during the installation process.

    *

    * <p>It should be noted that any definitions (or redefinitions)

    * made by the files processed WILL AFFECT all subsequent files

    * processed (I may add a version of this macro which saves/restores

    * the macros for each file processed).

    *

    * <p>To see the power of this function, take a look at the {@link

    * <a href=doc-files/atcopy.atmacros>atcopy.atmacros</a>}

    * "script". It does the following:

    *

    * <ul>

    *

    * <li>Makes some of its own definitions.</li>

    *

    * <li>Loads a set of definitions ({@link

    * <a href=doc-files/htmlmemo.atmacros>htmlmemo.atmacros</a>}).</li>

    *

    * <li>Then copies a set of HTML documents (both {@link

    * <a href=doc-files/memo1.html>memo1.html</a>} and  {@link

    * <a href=doc-files/memo2.html>memo2.html</a>}) using the defined macros.

    *

    * </ul>

    *

    * <p>If you have the source code installed such that the "ccg" top

    * level directory can be found under the "$COMHOME" environment

    * variable, you should be able to try this out via:

    *

    * <pre>

    * java {@link At com.ccg.macros.At} -Dcomhome=$COMHOME -Dhtmlroot=$HOME/public_html \

    *   -in {@link <a href=doc-files/atcopy.atmacros>$COMHOME/ccg/macros/doc-files/atcopy.atmacros</a>}

    * </pre>

    *

    * @param        out

    * 

    *         The {@link Output output device} to write the results of

    *         processing the argument to.

    * 

    * @param        args

    * 

    *         A {@link Vector vector} of arguments which were passed to the macro.

    * 

    * @throws        IOException

    * 

    *         If there is a problem writing to the {@link Output output device}

    * 

    * @throws        InterpretException

    * 

    *         If a problem is encountered interpretting the arguments passed.

    * 

    * @since        1.0 */

   //----------------------------------------------------------------

   public void atCopyToDir(Output out, Vector args) 

     throws IOException, InterpretException {

     int argc = args.size();

     if (argc < 2) return;        // must have at least two arguments

     argc--;                        // last argument is the output directory

                                 // get output directory

     String dstStr = getStringParameter(args,argc);

     File dst = new File(FileName.fixSlashes(dstStr));

                                 // try to create directory - if it

                                 // doesn't exist

     if (!dst.isDirectory()) {

       dst.mkdirs();

       if (!dst.isDirectory()) {

         throw new IOException("unable to create directory \""+dst+"\"");

       }

     }

     PrintWriterString pws = PrintWriterString.create();

                                 // now, process each of the wild-card

                                 // file name strings

     for (int i = 0; i < argc; i++) {

       String match = getStringParameter(args,i);

       String[] list = FilenameFilterWild.list(FileName.fixSlashes(match));

           if (Debug.ENABLED && Debug.isEnabledFor(3)) {

             int cnt = 0;

             if (null != list) {

               cnt = list.length;

             }

             pws.println("Matched: " + cnt + " files via: \"" + match + "\"");

           }

           if (list != null) for (int j = 0; j < list.length; j++) {

             File src = new File(list[j]);

                                 // only copy existing normal files

             if (src.exists() && src.isFile()) {

               File ofile = new File(dst,src.getName());

               pws.print("Interpret[" + j + "]:");

               pws.print(src);

               pws.print("  to:");

               pws.println(dst);

               if (Debug.ENABLED && Debug.isEnabledFor(3)) {

                 Debug.out("Interpret:" + src + "  to:" + dst);

               }

               OutputWriter ow = new OutputWriter(ofile);

               InputReader ir = new InputReader(src);

                                 // and copy/interpret the files

               getAtMacros().interpretCheck(ir,ow);

               ow.close();                // don't forget to close (to flush out data)

             } else if (Debug.ENABLED && Debug.isEnabledFor(3)) {

               pws.print("Skip:");

               pws.println(src);

             }

       }

     }

     out.write(pws);

   }

   //----------------------------------------------------------------

   /** @atCopyFile(SRC,DST) copy AND interpret one file to another.

    * 

    * <p>This macro is used to copy exactly one file from one location

    * to another. If the DST is a directory, then the same file name

    * will be preserved, if DST does not include a directory, then the

    * same directory as the SRC will be assumed. The final DST must not

    * be the same as the SRC (or we will report an error and skip the

    * copy). If the destination directory doesn't exist, it will be

    * created.

    *

    * <p>There is a HUGE difference between this command and the

    * "@copyFile". This command interprets each file that it

    * copies and evaluates any "&#064macros" which it contains. This

    * can be a VERY useful way to install HTML (or other text)

    * documents to their final location and do some subsitutions during

    * the installation process.

    *

    * <p>It should be noted that any definitions (or redefinitions)

    * made by the files processed WILL AFFECT all subsequent files

    * processed (I may add a version of this macro which saves/restores

    * the macros for each file processed).

    *

    * @param        out

    * 

    *         The {@link Output output device} to write the results of

    *         processing the argument to.

    * 

    * @param        args

    * 

    *         A {@link Vector vector} of arguments which were passed to the macro.

    * 

    * @throws        IOException

    * 

    *         If there is a problem writing to the {@link Output output device}

    * 

    * @throws        InterpretException

    * 

    *         If a problem is encountered interpretting the arguments passed.

    * 

    * @since        1.0 */

   //----------------------------------------------------------------

   public void atCopyFile(Output out, Vector args) 

     throws IOException, InterpretException {

     int argc = args.size();

     if (argc != 2) {

       throw new InterpretException("@atCopyToDir(SRC,DST) - "+

                                    "requires exactly 2 parameters");

     }

     String srcStr = FileName.fixSlashes(getStringParameter(args,0));

     String dstStr = FileName.fixSlashes(getStringParameter(args,1));

     File src = new File(srcStr);

     InputStream isrc = null;

     if (!src.isFile()) {

       isrc = com.ccg.io.Utility.getInputStream(srcStr);

       if (isrc == null) {

         throw new IOException("\""+srcStr+"\" is not a readable file");

       }

     }

     File dst = new File(dstStr);

     File dstDir = dst.getParentFile();

     if (dstDir == null) {

       dstDir = src.getParentFile();

       if (dstDir != null) dst = new File(dstDir,dstStr);

     }

     else if (dst.isDirectory()) {

       dstDir = dst;

       dst = new File(dstDir,dstStr);

     }

     if ((src != null) && dst.equals(src)) {

       throw new IOException("source & destination files are both \""+src+"\"");

     }

                                 // try to create directory - if it

                                 // doesn't exist

     if (!dstDir.isDirectory()) {

       dstDir.mkdirs();

       if (!dstDir.isDirectory()) {

         throw new IOException("unable to create directory \""+dstDir+"\"");

       }

     }

     if (Debug.ENABLED && Debug.isEnabledFor(3)) {

       Debug.out("Interpret copy from \""+srcStr+"\" to \""+dst+"\"");

     }

     OutputWriter ow = null;

     InputReader ir = null;

     try {

       ow = new OutputWriter(dst);

       if (isrc != null) {

         ir = new InputReader(isrc);

       }

       else {

         ir = new InputReader(src);

       }

                                 // and copy/interpret the files

       getAtMacros().interpretCheck(ir,ow);

     } finally {

       if (ow != null) try { ow.close(); } catch (Throwable t) { }

       if (ir != null) try { ir.close(); } catch (Throwable t) { }

     }

     if (Debug.ENABLED && Debug.isEnabledFor(3)) {

       Debug.out("Successfully processed \""+srcStr+"\" to \""+dst+"\"");

     }

   }

   //----------------------------------------------------------------

   /** @copyFile(SRC,DST) copy one file to another.

    * 

    * <p>This macro is used to copy exactly one file from one location

    * to another. If the DST is a directory, then the same file name

    * will be preserved, if DST does not include a directory, then the

    * same directory as the SRC will be assumed. The final DST must not

    * be the same as the SRC (or we will report an error and skip the

    * copy). If the destination directory doesn't exist, it will be

    * created.

    *

    * <p>There is a HUGE difference between this command and the

    * "@atCopyFile". This command does no interpretation (it

    * simply copies the bytes from the source file to the destination

    * file). This makes it well suited for transferring images (or any

    * file where interpretation of the file contents doesn't make

    * sense).

    *

    * @param        out

    * 

    *         The {@link Output output device} to write the results of

    *         processing the argument to.

    * 

    * @param        args

    * 

    *         A {@link Vector vector} of arguments which were passed to the macro.

    * 

    * @throws        IOException

    * 

    *         If there is a problem writing to the {@link Output output device}

    * 

    * @throws        InterpretException

    * 

    *         If a problem is encountered interpretting the arguments passed.

    * 

    * @since        1.0 */

   //----------------------------------------------------------------

   public void copyFile(Output out, Vector args) 

     throws IOException, InterpretException {

     int argc = args.size();

     if (argc != 2) {

       throw new InterpretException("@copyToDir(SRC,DST) - "+

                                    "requires exactly 2 parameters");

     }

     String srcStr = FileName.fixSlashes(getStringParameter(args,0));

     String dstStr = FileName.fixSlashes(getStringParameter(args,1));

     File src = new File(srcStr);

     if (!src.isFile()) {

       throw new IOException("\""+src+"\" is not a readable file");

     }

     File dst = new File(dstStr);

     File dstDir = dst.getParentFile();

     if (dstDir == null) {

       dstDir = src.getParentFile();

       if (dstDir != null) dst = new File(dstDir,dstStr);

     }

     else if (dst.isDirectory()) {

       dstDir = dst;

       dst = new File(dstDir,dstStr);

     }

     if (dst.equals(src)) {

       throw new IOException("source & destination files are both \""+src+"\"");

     }

                                 // try to create directory - if it

                                 // doesn't exist

     if (!dstDir.isDirectory()) {

       dstDir.mkdirs();

       if (!dstDir.isDirectory()) {

         throw new IOException("unable to create directory \""+dstDir+"\"");

       }

     }

     if (Debug.ENABLED && Debug.isEnabledFor(3)) {

       Debug.out("About to copy \""+src+"\" to \""+dst+"\"");

     }

     Copy.fileToFile(src,dst);

     if (Debug.ENABLED && Debug.isEnabledFor(3)) {

       Debug.out("Successfully copied \""+src+"\" to \""+dst+"\"");

     }

   }

   //----------------------------------------------------------------

   /** @ifFileExists(NAME,IF_EXISTS,IF_NOT) determine if file exists.

    * 

    * <p>This macro is used to make a decistion based upon whether a

    * file exists or not. If the file specified byte <b>NAME</b>

    * exists, then the <b>IF_EXISTS</b> clause is evaluated. If not,

    * then the <b>IF_NOT</b> clause is evaluated.</p>

    *

    * @param        out

    * 

    *         The {@link Output output device} to write the results of

    *         processing the argument to.

    * 

    * @param        args

    * 

    *         A {@link Vector vector} of arguments which were passed to the macro.

    * 

    * @throws        IOException

    * 

    *         If there is a problem writing to the {@link Output output device}

    * 

    * @throws        InterpretException

    * 

    *         If a problem is encountered interpretting the arguments passed.

    * 

    * @since        1.0 */

   //----------------------------------------------------------------

   public void ifFileExists(Output out, Vector args) 

     throws IOException, InterpretException {

     int argc = args.size();

     if ((argc != 2) && (argc != 3)) {

       throw new InterpretException("@ifFileExists(NAME,IF_EXIST,IFNOT) - "+

                                    "requires 2 or 3 parameters");

     }

                                 // get output directory

     AtMacros am = getAtMacros();

     String srcStr = FileName.fixSlashes(getStringParameter(args,0));

     File src = new File(srcStr);

     if (src.exists()) {

       out.write(am.interpretCheck(getStringParameter(args,1)));

     }

     else {

       out.write(am.interpretCheck(getStringParameter(args,2)));

     }

   }

 }

 //----------------------------------------------------------------  

 // Helper class(es)

 //----------------------------------------------------------------

 //----------------------------------------------------------------  

 // Helper class to process each row of a data table

 //----------------------------------------------------------------

 class TableField implements MacroHandler {

   private AtMacros _AtMacros;

   private TableInsert _Table;

   private String _Name;

   TableField(AtMacros am, String name, TableInsert ti) {

     _AtMacros = am;

     _Table = ti;

     _Name = name;

   }

   public void process(Output out, Vector args)

     throws IOException, InterpretException {

     if (args.size() != 1) {

       throw new InterpretException("Error: @"+_Name+"(FIELD) requires "+

                                    "one argument");

     }

     String val = args.elementAt(0).toString();

     int index = -1;

     if (Character.isDigit(val.charAt(0))) try {

       index = Integer.parseInt(val);

     } catch (Exception e) { }

     if (index < 0) index = _Table.getTable().getTableColumn(val);

     if (index < 0) {

       throw new InterpretException("Error: @"+_Name+"("+val+") has a "+

                                    "non-integer index specified");

     }

     out.write(_AtMacros.interpretCheck(_Table.getTable().getFieldString(index,"")));

   }

 }

 class TableInsert extends TableProcessor implements MacroHandler {

   private AtMacros _AtMacros;

   private String _Source;

   private String _Name;

   private String _Format;

   private Output _Out;

   TableInsert(AtMacros am, String name, String source) {

     super(null);

     _AtMacros = am;

     _Name = name;

     _Source = source;

     _Format = "";

   }

   public boolean processData() {

     try {

       _Out.write(_AtMacros.interpretCheck(_Format));

     } catch (Exception ioe) {

       setDataException(ioe);

       return false;

     }

     return true;

   }

   public void process(Output out, Vector args)

     throws IOException, InterpretException {

     _Format = "";

     if (args.size() >= 1) _Format = args.elementAt(0).toString();

     if (_Format.length() == 0)

       throw new InterpretException("Error: no FORMAT specified to @"+

                                    _Name+"(FORMAT)");

     LineNumberReader lnr =

       new LineNumberReader(com.ccg.io.Utility.getReader(_Source));

     setTable(new TextTable());

     String fmac = _Name+"F";

     _AtMacros.addMacro(fmac,new TableField(_AtMacros,fmac,this));

     _Out = out;

     process(lnr);

     _AtMacros.addMacro(fmac,(MacroHandler) null);

     Exception re = getDataException();

     if (re == null) re = getHeaderException();

     try {

       lnr.close();

     } catch (IOException ioe) {

       re = ioe;

     }

     if (re != null) {

       if (re instanceof IOException) throw (IOException) re;

       else throw (InterpretException) re;

     }

   }

 }