// Copyright (c) 2003, Chad Woolley, All rights reserved.
   
   package org.virtualmock.taskdef;
   
   import java.io.File;
   import java.util.StringTokenizer;
   import org.apache.tools.ant.BuildException;
   import org.apache.tools.ant.Task;
   import org.apache.tools.ant.taskdefs.Delete;
  import org.apache.tools.ant.taskdefs.Java;
  import org.apache.tools.ant.taskdefs.Zip;
  import org.apache.tools.ant.types.Commandline.Argument;
  import org.apache.tools.ant.types.CommandlineJava;
  import org.apache.tools.ant.types.FileSet;
  import org.apache.tools.ant.types.Path;
  
  
  /***
   * Task to perform transformation of class or jar files to be executed with
   * VirtualMock.
   *
   * @author Chad Woolley
   * @version $Revision: 1.18 $
   */
  public class VMTransformTask extends Task {
      private CommandlineJava commandline = null;
      private Path classpath = null;
      private String aspectWerkzClassname =
          "org.codehaus.aspectwerkz.compiler.AspectWerkzC";
      private String aspectjClassname = "org.aspectj.tools.ajc.Main";
      private String aspectpath = null;
      private String aspectpathJarPrefix = "virtualmock-aspect-";
      private String injars = null;
      private String outjar = null;
      private boolean useAspectJ = true;
      private boolean useAspectWerkz = false;
  
      /***
       * Creates a new VMTransformTask object.
       */
      public VMTransformTask() {
          super();
          this.setTaskName("vmtransform");
          commandline = new CommandlineJava();
      }
  
      /***
       * Sets the classname for the AspectWerkz compiler.
       *
       * @param aspectWerkzClassname The aspectWerkzClassname to set.
       */
      public void setAspectWerkzClassname(String aspectWerkzClassname) {
          this.aspectWerkzClassname = aspectWerkzClassname;
      }
  
      /***
       * Gets the classname for the AspectWerkz compiler.
       *
       * @return Returns the aspectWerkzClassname.
       */
      public String getAspectWerkzClassname() {
          return aspectWerkzClassname;
      }
  
      /***
       * Sets the classname for the AspectJ compiler.
       *
       * @param aspectjClassname The aspectjClassname to set.
       */
      public void setAspectjClassname(String aspectjClassname) {
          this.aspectjClassname = aspectjClassname;
      }
  
      /***
       * Gets the classname for the AspectJ compiler.
       *
       * @return Returns the aspectjClassname.
       */
      public String getAspectjClassname() {
          return aspectjClassname;
      }
  
      /***
       * Sets jar containing VirtualMock aspect classes to weave.  If this is not
       * specified, then the aspectpathJarPrefix will be used to search for the
       * aspectjar on the classpath.
       *
       * @param aspectpath the aspectpath to set
       */
      public void setAspectpath(String aspectpath) {
          this.aspectpath = aspectpath;
      }
  
      /***
       * Gets jar containing VirtualMock aspect classes to weave.  If this is not
       * specified, then the aspectpathJarPrefix will be used to search for the
       * aspectjar on the classpath.
       *
       * @return Returns the aspectpath.
      */
     public String getAspectpath() {
         return aspectpath;
     }
 
     /***
      * Sets string which will be used to search the classpath for the
      * aspectpath jar (using String.indexOf(String)).  If this is not
      * specified, it will default to "virtualmock-aspect-".
      *
      * @param aspectpathJarPrefix the aspectpathJarPrefix to set
      */
     public void setAspectpathJarPrefix(String aspectpathJarPrefix) {
         this.aspectpathJarPrefix = aspectpathJarPrefix;
     }
 
     /***
      * Gets string which will be used to search the classpath for the
      * aspectpath jar (using String.indexOf(String)).  If this is not
      * specified, it will default to "virtualmock-aspect-".
      *
      * @return Returns the aspectpathJarPrefix.
      */
     public String getAspectpathJarPrefix() {
         return aspectpathJarPrefix;
     }
 
     /***
      * Sets the classpath to use.
      *
      * @param classpath The classpath to set.
      */
     public void setClasspath(Path classpath) {
         this.classpath = classpath;
     }
 
     /***
      * Gets the currently set classpath.
      *
      * @return Returns the classpath.
      */
     public Path getClasspath() {
         return classpath;
     }
 
     /***
      * Sets the command line.
      *
      * @param commandline The commandline to set.
      */
     public void setCommandline(CommandlineJava commandline) {
         this.commandline = commandline;
     }
 
     /***
      * Gets the command line.
      *
      * @return Returns the commandline.
      */
     public CommandlineJava getCommandline() {
         return commandline;
     }
 
     /***
      * Setter for the input jars.    Accept as source bytecode any .class files
      * inside the specified .jar files. The output will include these classes,
      * possibly as woven with any applicable aspects.  Like classpath, this is
      * a single argument containing a list of paths to jar files, delimited by
      * the platform- specific classpath delimiter.
      *
      * @param injars the injars to set
      */
     public void setInjars(String injars) {
         this.injars = injars;
     }
 
     /***
      * The input jars which will be woven.
      *
      * @return Returns the injars.
      */
     public String getInjars() {
         return injars;
     }
 
     /***
      * Sets the output jar.  This is the transformed jar which will be created
      * by this task.
      *
      * @param outjar the outjar to set
      */
     public void setOutjar(String outjar) {
         this.outjar = outjar;
     }
 
     /***
      * Gets the output jar.  This is the transformed jar which will be created
      * by this task.
      *
      * @return Returns the outjar.
      */
     public String getOutjar() {
         return outjar;
     }
 
     /***
      * Indicates whether AspectJ should be used as the Aspect-Oriented
      * Programming (AOP) framework.
      *
      * @param useAspectJ flag indicating whether AspectJ should be used.
      */
     public void setUseAspectJ(boolean useAspectJ) {
         this.useAspectJ = useAspectJ;
         useAspectWerkz = !useAspectJ;
     }
 
     /***
      * Returns flag which indicates whether AspectJ should be used to weave.
      *
      * @return Returns the flag which indicates whether AspectJ should be used
      *         to weave.
      */
     public boolean isUseAspectJ() {
         return useAspectJ;
     }
 
     /***
      * Sets the flag which indicates whether AspectWerkz should be used to
      * weave.
      *
      * @param useAspectWerkz flag indicating whether AspectWerkz should be used
      *        to weave.
      */
     public void setUseAspectWerkz(boolean useAspectWerkz) {
         this.useAspectWerkz = useAspectWerkz;
         useAspectJ = !useAspectWerkz;
     }
 
     /***
      * Returns the flag which indicates whether AspectWerkz should be used to
      * weave.
      *
      * @return Returns the flag indicating whether AspectWerkz should be used
      *         to weave.
      */
     public boolean isUseAspectWerkz() {
         return useAspectWerkz;
     }
 
     /***
      * Overridden method to handle classpath.  It will take the classpath that
      * is currently specified, and  append all elements required to support
      * the VirtualMock environment.
      *
      * @return the modified classpath
      *
      * @todo Do we need to add anything to the classpath?  If so, what?
      * @todo What about forked mode?
      */
     public Path createClasspath() {
         // get a local instance variable handle to the classpath
         classpath = commandline.createClasspath(getProject()).createPath();
 
         return classpath;
     }
 
     /***
      * Perform execution of the task, first performing necessary setup to run
      * VirtualMock unit tests.
      *
      * @throws BuildException DOCUMENT ME! (Constructor Exception)
      */
     public void execute() throws BuildException {
         File outjarFile = new File(outjar);
 
         deleteOutjarFile(outjarFile);
 
         String className = null;
         String args = null;
 
         if (useAspectJ) {
             // set the class name
             className = aspectjClassname;
 
             performAspectjPreProcessing();
 
             // define the command line args
             args =
                 "-outjar " + outjar + " -injars " + injars + " -aspectpath "
                 + aspectpath;
         }
 
         if (useAspectWerkz) {
             // set the class name
             className = aspectWerkzClassname;
 
             // define the command line args
             args = "-haltOnError " + outjar;
 
             performAspectwerkzPreProcessing(outjarFile);
         }
 
         // use the Ant Execute task to execute VirtualMock transformation
         Java java = new Java();
 
         // use the VM launcher
         java.setFork(false);
 
         // set the class name
         java.setClassname(className);
 
         // fail on error
         java.setFailonerror(true);
 
         Argument arg = java.createArg();
         arg.setLine(args);
 
         java.setClasspath(classpath);
 
         // execute the command
         int returnCode = -1;
 
         java.setProject(project);
 
         java.setFork(true);
         returnCode = java.executeJava();
 
         if (returnCode != 0) {
             throw new BuildException(
                 "VirtualMock transformation failed, return code = "
                 + returnCode + ".  Command executed was '" + className
                 + "' with arguments '" + args + "'");
         }
     }
 
     /***
      * If aspectpath was not set by user, search the classpath for the jar
      * containing the virtualmock aspects and set it in the aspectpath
      * variable.
      */
     protected void setDefaultAspectPath() {
         String[] classpathElements = classpath.list();
 
         for (int i = 0; i < classpathElements.length; i++) {
             if (classpathElements[i].indexOf(aspectpathJarPrefix) != -1) {
                 aspectpath = classpathElements[i];
             }
         }
     }
 
     /***
      * Delete the output jar, if it exists.
      *
      * @param outjarFile the File object representing the outjar
      */
     protected void deleteOutjarFile(File outjarFile) {
         // delete the output jar, if it exists
         Delete delete = new Delete();
         delete.setProject(project);
 
         delete.setFile(outjarFile);
         delete.setFailOnError(false);
         delete.execute();
     }
 
     /***
      * Performs preprocessing that is specific to AspectJ.
      */
     protected void performAspectjPreProcessing() {
         // perform processing specific to AspectJ
         if (aspectpath == null) {
             setDefaultAspectPath();
         }
     }
 
     /***
      * Performs preprocessing that is specific to AspectWerkz.
      *
      * @param outjarFile the File object represented by outjar
      */
     protected void performAspectwerkzPreProcessing(File outjarFile) {
         // perform processing for AspectWerkz
         // combine all injars into a single jar which will be transformed with AspectWerkz
         Zip zip = new Zip();
         zip.setProject(project);
         zip.setDestFile(outjarFile);
 
         // get a tokenizer to split up the injars
         StringTokenizer stringTokenizer =
             new StringTokenizer(injars, File.pathSeparator);
 
         while (stringTokenizer.hasMoreTokens()) {
             // split each injar into a dir and file, and add as an
             // individual zipgroupfileset
             String injarFileStringFull = stringTokenizer.nextToken();
             File injarFile = new File(injarFileStringFull);
             String parentDir = injarFile.getParent();
             File parentDirFile = new File(parentDir);
             String injarFileString =
                 injarFileStringFull.substring(parentDir.length() + 1);
 
             FileSet fileSet = new FileSet();
             fileSet.setIncludes(injarFileString);
             fileSet.setDir(parentDirFile);
             zip.addZipGroupFileset(fileSet);
         }
 
         // don't add any duplicate files
         Zip.Duplicate duplicate = new Zip.Duplicate();
         duplicate.setValue("preserve");
         zip.setDuplicate(duplicate);
 
         // make the zip
         zip.execute();
     }
 }