NarTestCompileMojo.java

/*
 * #%L
 * Native ARchive plugin for Maven
 * %%
 * Copyright (C) 2002 - 2014 NAR Maven Plugin developers.
 * %%
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 * 
 * http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 * #L%
 */
package com.github.maven_nar;

import java.io.File;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;

import org.apache.maven.artifact.Artifact;
import org.apache.maven.plugin.MojoExecutionException;
import org.apache.maven.plugin.MojoFailureException;
import org.apache.maven.plugins.annotations.LifecyclePhase;
import org.apache.maven.plugins.annotations.Mojo;
import org.apache.maven.plugins.annotations.Parameter;
import org.apache.maven.plugins.annotations.ResolutionScope;
import org.apache.maven.shared.artifact.filter.collection.ScopeFilter;
import org.apache.tools.ant.BuildException;
import org.apache.tools.ant.Project;

import com.github.maven_nar.cpptasks.CCTask;
import com.github.maven_nar.cpptasks.CUtil;
import com.github.maven_nar.cpptasks.CompilerDef;
import com.github.maven_nar.cpptasks.LinkerDef;
import com.github.maven_nar.cpptasks.OutputTypeEnum;
import com.github.maven_nar.cpptasks.RuntimeType;
import com.github.maven_nar.cpptasks.SubsystemEnum;
import com.github.maven_nar.cpptasks.types.LibrarySet;
import com.github.maven_nar.cpptasks.types.LibraryTypeEnum;
import com.github.maven_nar.cpptasks.types.LinkerArgument;
import com.github.maven_nar.cpptasks.types.SystemLibrarySet;

/**
 * Compiles native test source files.
 * 
 * @author Mark Donszelmann
 */
@Mojo(name = "nar-testCompile", defaultPhase = LifecyclePhase.TEST_COMPILE,
  requiresDependencyResolution = ResolutionScope.TEST)
public class NarTestCompileMojo extends AbstractCompileMojo {
  /**
   * Skip running of NAR integration test plugins.
   */
  @Parameter(property = "skipNar")
  protected boolean skipNar;

  private void createTest(final Project antProject, final Test test)
      throws MojoExecutionException, MojoFailureException {
    final String type = "test";

    // configure task
    final CCTask task = new CCTask();
    task.setProject(antProject);

    // subsystem
    final SubsystemEnum subSystem = new SubsystemEnum();
    subSystem.setValue("console");
    task.setSubsystem(subSystem);

    // outtype
    final OutputTypeEnum outTypeEnum = new OutputTypeEnum();
    outTypeEnum.setValue(test.getType());
    task.setOuttype(outTypeEnum);

    // outDir
    File outDir = new File(getTestTargetDirectory(), "bin");
    outDir = new File(outDir, getAOL().toString());
    outDir.mkdirs();

    // outFile
    final File outFile = new File(outDir, test.getName());
    getLog().debug("NAR - output: '" + outFile + "'");
    task.setOutfile(outFile);

    // object directory
    File objDir = new File(getTestTargetDirectory(), "obj");
    objDir = new File(objDir, getAOL().toString());
    objDir.mkdirs();
    task.setObjdir(objDir);

    // failOnError, libtool
    task.setFailonerror(failOnError(getAOL()));
    task.setLibtool(useLibtool(getAOL()));

    // runtime
    final RuntimeType runtimeType = new RuntimeType();
    runtimeType.setValue(getRuntime(getAOL()));
    task.setRuntime(runtimeType);

    // add C++ compiler
    final Cpp cpp = getCpp();
    if (cpp != null) {
      final CompilerDef cppCompiler = getCpp().getTestCompiler(type, test.getName());
      if (cppCompiler != null) {
        task.addConfiguredCompiler(cppCompiler);
      }
    }

    // add C compiler
    final C c = getC();
    if (c != null) {
      final CompilerDef cCompiler = c.getTestCompiler(type, test.getName());
      if (cCompiler != null) {
        task.addConfiguredCompiler(cCompiler);
      }
    }

    // add Fortran compiler
    final Fortran fortran = getFortran();
    if (fortran != null) {
      final CompilerDef fortranCompiler = getFortran().getTestCompiler(type, test.getName());
      if (fortranCompiler != null) {
        task.addConfiguredCompiler(fortranCompiler);
      }
    }

    // add java include paths
    getJava().addIncludePaths(task, type);

    getMsvc().configureCCTask(task);

    List depLibs = getNarArtifacts();
    
    // add dependency include paths
    for (final Object depLib1 : depLibs) {
      final Artifact artifact = (Artifact) depLib1;

      // check if it exists in the normal unpack directory
      File include = getLayout()
          .getIncludeDirectory(getUnpackDirectory(), artifact.getArtifactId(), artifact.getBaseVersion());
      if (!include.exists()) {
        // otherwise try the test unpack directory
        include = getLayout()
            .getIncludeDirectory(getTestUnpackDirectory(), artifact.getArtifactId(), artifact.getBaseVersion());
      }
      if (include.exists()) {
        task.createIncludePath().setPath(include.getPath());
      }
    }

    // add javah generated include path
    final File jniIncludeDir = getJavah().getJniDirectory();
    if (jniIncludeDir.exists()) {
      task.createIncludePath().setPath(jniIncludeDir.getPath());
    }

    // add linker
    final LinkerDef linkerDefinition = getLinker().getTestLinker(this, task, getOS(), getAOL().getKey() + ".linker.",
        type);
    task.addConfiguredLinker(linkerDefinition);

    final File includeDir = getLayout().getIncludeDirectory(getTargetDirectory(), getMavenProject().getArtifactId(),
        getMavenProject().getVersion());

    String linkType = test.getLink( getLibraries() );
    final File libDir = getLayout().getLibDirectory(getTargetDirectory(), getMavenProject().getArtifactId(),
        getMavenProject().getVersion(), getAOL().toString(), linkType);

    // copy shared library
    // FIXME why do we do this ?
    /*
     * Removed in alpha-10 if (test.getLink().equals(Library.SHARED)) { try { //
     * defaults are Unix String libPrefix
     * = NarUtil.getDefaults().getProperty( getAOLKey() + "shared.prefix",
     * "lib"); String libExt =
     * NarUtil.getDefaults().getProperty( getAOLKey() + "shared.extension",
     * "so"); File copyDir = new
     * File(getTargetDirectory(), (getOS().equals( "Windows") ? "bin" : "lib") +
     * "/" + getAOL() + "/" +
     * test.getLink()); FileUtils.copyFileToDirectory(new File(libDir, libPrefix
     * + libName + "." + libExt),
     * copyDir); if (!getOS().equals(OS.WINDOWS)) { libDir = copyDir; } } catch
     * (IOException e) { throw new
     * MojoExecutionException( "NAR: Could not copy shared library", e); } }
     */
    // FIXME what about copying the other shared libs?

    // add include of this package
    if (includeDir.exists()) {
      task.createIncludePath().setLocation(includeDir);
    }

    // add library of this package
    if (libDir.exists()) {
      final LibrarySet libSet = new LibrarySet();
      libSet.setProject(antProject);

      // String libs = getNarInfo().getLibs( getAOL() );
      // using getNarInfo().getLibs( getAOL() ); forces to execute the goal
      // nar-prepare-package prior to
      // nar-testCompile in order to set the "output" property in narInfo with
      // the call :
      // narInfo.setOutput( null, mojo.getOutput(true) ); (set in
      // NarLayout21.prepareNarInfo(...))

      // narInfo.getLibs(aol) call in fact narInfo.getProperty( aol,
      // "libs.names", getOutput( aol, artifactId + "-" + version ) );
      // where getOutput is the getOutput method in narInfo (which needs the
      // "output" property).
      // We call then directly narInfo.getProperty( aol, "libs.names", <output
      // value>); but we set <output value>
      // with AbstractCompileMojo.getOutput( boolean versioned ) as it is done
      // during nar-prepare-package
      final String libs = getNarInfo().getProperty(getAOL(), "libs.names", getOutput(true));

      getLog().debug("Searching for parent to link with " + libs);
      libSet.setLibs(new CUtil.StringArrayBuilder(libs));
      final LibraryTypeEnum libType = new LibraryTypeEnum();
      libType.setValue(linkType);
      libSet.setType(libType);
      libSet.setDir(libDir);
      task.addLibset(libSet);
    }

    // add dependency libraries
    final List depLibOrder = getDependencyLibOrder();

    // reorder the libraries that come from the nar dependencies
    // to comply with the order specified by the user
    if (depLibOrder != null && !depLibOrder.isEmpty()) {

      final List tmp = new LinkedList();

      for (final Object aDepLibOrder : depLibOrder) {

        final String depToOrderName = (String) aDepLibOrder;

        for (final Iterator j = depLibs.iterator(); j.hasNext(); ) {

          final NarArtifact dep = (NarArtifact) j.next();
          final String depName = dep.getGroupId() + ":" + dep.getArtifactId();

          if (depName.equals(depToOrderName)) {

            tmp.add(dep);
            j.remove();
          }
        }
      }

      tmp.addAll(depLibs);
      depLibs = tmp;
    }

    for (final Object depLib : depLibs) {
      final NarArtifact dependency = (NarArtifact) depLib;

      // FIXME no handling of "local"

      final String binding = getBinding(test, dependency);
      getLog().debug("Using Binding: " + binding);
      AOL aol = getAOL();
      aol = dependency.getNarInfo().getAOL(getAOL());
      getLog().debug("Using Library AOL: " + aol.toString());

      // We dont link against the following library types :
      // - JNI, they are Java libraries
      // - executable, they are not libraries
      // - none, they are not libraries ... I gess
      // Static libraries should be linked. Even though the libraries
      // themselves will have been tested already, the test code could
      // use methods or classes defined in them.
      if (!binding.equals(Library.JNI) && !binding.equals(Library.NONE) && !binding.equals(Library.EXECUTABLE)) {
        // check if it exists in the normal unpack directory
        File dir = getLayout()
            .getLibDirectory(getUnpackDirectory(), dependency.getArtifactId(), dependency.getBaseVersion(),
                aol.toString(), binding);
        getLog().debug("Looking for Library Directory: " + dir);
        if (!dir.exists()) {
          getLog().debug("Library Directory " + dir + " does NOT exist.");

          // otherwise try the test unpack directory
          dir = getLayout()
              .getLibDirectory(getTestUnpackDirectory(), dependency.getArtifactId(), dependency.getBaseVersion(),
                  aol.toString(), binding);
          getLog().debug("Looking for Library Directory: " + dir);
        }
        if (dir.exists()) {
          final LibrarySet libSet = new LibrarySet();
          libSet.setProject(antProject);

          // FIXME, no way to override
          final String libs = dependency.getNarInfo().getLibs(getAOL());
          if (libs != null && !libs.equals("")) {
            getLog().debug("Using LIBS = " + libs);
            libSet.setLibs(new CUtil.StringArrayBuilder(libs));
            libSet.setDir(dir);
            task.addLibset(libSet);
          }
        } else {
          getLog().debug("Library Directory " + dir + " does NOT exist.");
        }

        // FIXME, look again at this, for multiple dependencies we may need to
        // remove duplicates
        final String options = dependency.getNarInfo().getOptions(getAOL());
        if (options != null && !options.equals("")) {
          getLog().debug("Using OPTIONS = " + options);
          final LinkerArgument arg = new LinkerArgument();
          arg.setValue(options);
          linkerDefinition.addConfiguredLinkerArg(arg);
        }

        final String sysLibs = dependency.getNarInfo().getSysLibs(getAOL());
        if (sysLibs != null && !sysLibs.equals("")) {
          getLog().debug("Using SYSLIBS = " + sysLibs);
          final SystemLibrarySet sysLibSet = new SystemLibrarySet();
          sysLibSet.setProject(antProject);

          sysLibSet.setLibs(new CUtil.StringArrayBuilder(sysLibs));
          task.addSyslibset(sysLibSet);
        }
      }
    }

    // Add JVM to linker
    getJava().addRuntime(task, getJavaHome(getAOL()), getOS(), getAOL().getKey() + ".java.");

    // execute
    try {
      task.execute();
    } catch (final BuildException e) {
      throw new MojoExecutionException("NAR: Test-Compile failed", e);
    }
  }

  /**
   * List the dependencies needed for tests compilations, those dependencies are
   * used to get the include paths needed
   * for compilation and to get the libraries paths and names needed for
   * linking.
   */
  @Override
  protected ScopeFilter getArtifactScopeFilter() {
    // Was Artifact.SCOPE_TEST  - runtime??
    return new ScopeFilter( Artifact.SCOPE_TEST, null );
  }

  @Override
  protected File getUnpackDirectory() {
    return getTestUnpackDirectory() == null ? super.getUnpackDirectory() : getTestUnpackDirectory();
  }

  @Override
  public final void narExecute() throws MojoExecutionException, MojoFailureException {
    if (this.skipTests) {
      getLog().info("Not compiling test sources");
    } else {

      // make sure destination is there
      getTestTargetDirectory().mkdirs();

      for (final Object o : getTests()) {
        createTest(getAntProject(), (Test) o);
      }
    }
  }

}