artifacts compiler for compile server: fixed 'javaee facet classes' element to copy classes from selected source roots only

jps/jps-builders/src/org/jetbrains/jps/incremental/artifacts/ArtifactSourceFilesState.java

@@ -11,6 +11,7 @@ import org.jetbrains.jps.artifacts.LayoutElement;
 import org.jetbrains.jps.incremental.ModuleRootsIndex;
 import org.jetbrains.jps.incremental.artifacts.builders.LayoutElementBuildersRegistry;
 import org.jetbrains.jps.incremental.artifacts.instructions.*;
+import org.jetbrains.jps.incremental.storage.BuildDataManager;
 import org.jetbrains.jps.incremental.storage.CompositeStorageOwner;
 import org.jetbrains.jps.incremental.storage.StorageOwner;
 
@@ -75,7 +76,7 @@ public class ArtifactSourceFilesState extends CompositeStorageOwner {
     return myDeletedFiles;
   }
 
-  public void initState() throws IOException {
+  public void initState(final BuildDataManager dataManager) throws IOException {
     final Set<String> currentPaths = new HashSet<String>();
     myChangedFiles.clear();
     myDeletedFiles.clear();
@@ -84,7 +85,7 @@ public class ArtifactSourceFilesState extends CompositeStorageOwner {
       public boolean process(ArtifactSourceRoot root, int rootIndex, Collection<DestinationInfo> destinations) throws IOException {
         final File rootFile = root.getRootFile();
         if (rootFile.exists()) {
-          processRecursively(rootFile, rootIndex, root.getFilter(), currentPaths);
+          processRecursively(rootFile, rootIndex, dataManager, root.getFilter(), currentPaths);
         }
         return true;
       }
@@ -99,15 +100,15 @@ public class ArtifactSourceFilesState extends CompositeStorageOwner {
     }
   }
 
-  private void processRecursively(File file, int rootIndex, SourceFileFilter filter, Set<String> currentPaths) throws IOException {
+  private void processRecursively(File file, int rootIndex, BuildDataManager dataManager, SourceFileFilter filter, Set<String> currentPaths) throws IOException {
     final String filePath = FileUtil.toSystemIndependentName(FileUtil.toCanonicalPath(file.getPath()));
-    if (!filter.accept(filePath)) return;
+    if (!filter.accept(filePath, dataManager)) return;
 
     if (file.isDirectory()) {
       final File[] children = file.listFiles();
       if (children != null) {
         for (File child : children) {
-          processRecursively(child, rootIndex, filter, currentPaths);
+          processRecursively(child, rootIndex, dataManager, filter, currentPaths);
         }
       }
     }

jps/jps-builders/src/org/jetbrains/jps/incremental/artifacts/IncArtifactBuilder.java

@@ -73,7 +73,7 @@ public class IncArtifactBuilder extends ProjectLevelBuilder {
     try {
       final ArtifactSourceFilesState state = dataManager.getArtifactsBuildData().getOrCreateState(artifact,
                                                                                                   context.getProject(), context.getRootsIndex());
-      state.initState();
+      state.initState(dataManager);
       final Set<String> deletedFiles = state.getDeletedFiles();
       final Map<String,IntArrayList> changedFiles = state.getChangedFiles();
       if (deletedFiles.isEmpty() && changedFiles.isEmpty()) {
@@ -142,7 +142,7 @@ public class IncArtifactBuilder extends ProjectLevelBuilder {
           if (sourcePaths == null) return true;
 
           for (String sourcePath : sourcePaths) {
-            if (!root.containsFile(sourcePath)) continue;//todo[nik] this seems to be unnecessary
+            if (!root.containsFile(sourcePath, dataManager)) continue;//todo[nik] this seems to be unnecessary
 
             for (DestinationInfo destination : destinations) {
               if (destination instanceof ExplodedDestinationInfo) {

jps/jps-builders/src/org/jetbrains/jps/incremental/artifacts/builders/LayoutElementBuilderService.java

@@ -7,6 +7,16 @@ import org.jetbrains.jps.incremental.artifacts.instructions.ArtifactInstructions
 /**
  * @author nik
  */
-public abstract class LayoutElementBuilder<E extends LayoutElement> {
+public abstract class LayoutElementBuilderService<E extends LayoutElement> {
+  private final Class<E> myElementClass;
+
+  protected LayoutElementBuilderService(Class<E> elementClass) {
+    myElementClass = elementClass;
+  }
+
   public abstract void generateInstructions(E element, ArtifactCompilerInstructionCreator instructionCreator, ArtifactInstructionsBuilderContext builderContext);
+
+  public final Class<E> getElementClass() {
+    return myElementClass;
+  }
 }

jps/jps-builders/src/org/jetbrains/jps/incremental/artifacts/builders/LayoutElementBuildersRegistry.java

@@ -6,6 +6,7 @@ import com.intellij.openapi.util.text.StringUtil;
 import com.intellij.util.containers.ClassMap;
 import org.jetbrains.jps.Module;
 import org.jetbrains.jps.artifacts.*;
+import org.jetbrains.jps.idea.OwnServiceLoader;
 import org.jetbrains.jps.incremental.artifacts.instructions.ArtifactCompilerInstructionCreator;
 import org.jetbrains.jps.incremental.artifacts.instructions.ArtifactInstructionsBuilderContext;
 
@@ -26,24 +27,26 @@ public class LayoutElementBuildersRegistry {
     return InstanceHolder.ourInstance;
   }
 
-  private ClassMap<LayoutElementBuilder> myBuilders;
+  private ClassMap<LayoutElementBuilderService> myBuilders;
 
   private LayoutElementBuildersRegistry() {
-    myBuilders = new ClassMap<LayoutElementBuilder>();
-    myBuilders.put(RootElement.class, new RootElementBuilder());
-    myBuilders.put(DirectoryElement.class, new DirectoryElementBuilder());
-    myBuilders.put(ArchiveElement.class, new ArchiveElementBuilder());
-    myBuilders.put(DirectoryCopyElement.class, new DirectoryCopyElementBuilder());
-    myBuilders.put(FileCopyElement.class, new FileCopyElementBuilder());
-    myBuilders.put(ExtractedDirectoryElement.class, new ExtractedDirectoryElementBuilder());
-    myBuilders.put(ModuleOutputElement.class, new ModuleOutputElementBuilder());
-    myBuilders.put(ModuleTestOutputElement.class, new ModuleTestOutputElementBuilder());
-    myBuilders.put(ComplexLayoutElement.class, new ComplexElementBuilder());
+    myBuilders = new ClassMap<LayoutElementBuilderService>();
+    LayoutElementBuilderService<?>[] standardBuilders = {
+      new RootElementBuilder(), new DirectoryElementBuilder(), new ArchiveElementBuilder(), new DirectoryCopyElementBuilder(),
+      new FileCopyElementBuilder(), new ExtractedDirectoryElementBuilder(), new ModuleOutputElementBuilder(),
+      new ModuleTestOutputElementBuilder(), new ComplexElementBuilder(), new ArtifactOutputElementBuilder()
+    };
+    for (LayoutElementBuilderService<?> builder : standardBuilders) {
+      myBuilders.put(builder.getElementClass(), builder);
+    }
+    for (LayoutElementBuilderService builder : OwnServiceLoader.load(LayoutElementBuilderService.class)) {
+      myBuilders.put(builder.getElementClass(), builder);
+    }
   }
 
   public void generateInstructions(LayoutElement layoutElement, ArtifactCompilerInstructionCreator instructionCreator,
                                    ArtifactInstructionsBuilderContext builderContext) {
-    final LayoutElementBuilder builder = myBuilders.get(layoutElement.getClass());
+    final LayoutElementBuilderService builder = myBuilders.get(layoutElement.getClass());
     if (builder == null) {
       LOG.error("Builder not found for artifact output layout element of class " + layoutElement.getClass());
     }
@@ -84,14 +87,22 @@ public class LayoutElementBuildersRegistry {
     }
   }
 
-  private class RootElementBuilder extends LayoutElementBuilder<RootElement> {
+  private class RootElementBuilder extends LayoutElementBuilderService<RootElement> {
+    public RootElementBuilder() {
+      super(RootElement.class);
+    }
+
     @Override
     public void generateInstructions(RootElement element, ArtifactCompilerInstructionCreator instructionCreator, ArtifactInstructionsBuilderContext builderContext) {
       generateChildrenInstructions(element, instructionCreator, builderContext);
     }
   }
 
-  private class DirectoryElementBuilder extends LayoutElementBuilder<DirectoryElement> {
+  private class DirectoryElementBuilder extends LayoutElementBuilderService<DirectoryElement> {
+    public DirectoryElementBuilder() {
+      super(DirectoryElement.class);
+    }
+
     @Override
     public void generateInstructions(DirectoryElement element,
                                      ArtifactCompilerInstructionCreator instructionCreator,
@@ -100,7 +111,11 @@ public class LayoutElementBuildersRegistry {
     }
   }
 
-  private class ArchiveElementBuilder extends LayoutElementBuilder<ArchiveElement> {
+  private class ArchiveElementBuilder extends LayoutElementBuilderService<ArchiveElement> {
+    public ArchiveElementBuilder() {
+      super(ArchiveElement.class);
+    }
+
     @Override
     public void generateInstructions(ArchiveElement element, ArtifactCompilerInstructionCreator instructionCreator,
                                      ArtifactInstructionsBuilderContext builderContext) {
@@ -108,7 +123,11 @@ public class LayoutElementBuildersRegistry {
     }
   }
 
-  private static class DirectoryCopyElementBuilder extends LayoutElementBuilder<DirectoryCopyElement> {
+  private static class DirectoryCopyElementBuilder extends LayoutElementBuilderService<DirectoryCopyElement> {
+    public DirectoryCopyElementBuilder() {
+      super(DirectoryCopyElement.class);
+    }
+
     @Override
     public void generateInstructions(DirectoryCopyElement element, ArtifactCompilerInstructionCreator instructionCreator,
                                      ArtifactInstructionsBuilderContext builderContext) {
@@ -122,7 +141,11 @@ public class LayoutElementBuildersRegistry {
     }
   }
 
-  private static class FileCopyElementBuilder extends LayoutElementBuilder<FileCopyElement> {
+  private static class FileCopyElementBuilder extends LayoutElementBuilderService<FileCopyElement> {
+    public FileCopyElementBuilder() {
+      super(FileCopyElement.class);
+    }
+
     @Override
     public void generateInstructions(FileCopyElement element, ArtifactCompilerInstructionCreator instructionCreator,
                                      ArtifactInstructionsBuilderContext builderContext) {
@@ -137,7 +160,11 @@ public class LayoutElementBuildersRegistry {
     }
   }
 
-  private static class ExtractedDirectoryElementBuilder extends LayoutElementBuilder<ExtractedDirectoryElement> {
+  private static class ExtractedDirectoryElementBuilder extends LayoutElementBuilderService<ExtractedDirectoryElement> {
+    public ExtractedDirectoryElementBuilder() {
+      super(ExtractedDirectoryElement.class);
+    }
+
     @Override
     public void generateInstructions(ExtractedDirectoryElement element,
                                      ArtifactCompilerInstructionCreator instructionCreator,
@@ -151,7 +178,11 @@ public class LayoutElementBuildersRegistry {
     }
   }
 
-  private static class ModuleOutputElementBuilder extends LayoutElementBuilder<ModuleOutputElement> {
+  private static class ModuleOutputElementBuilder extends LayoutElementBuilderService<ModuleOutputElement> {
+    public ModuleOutputElementBuilder() {
+      super(ModuleOutputElement.class);
+    }
+
     @Override
     public void generateInstructions(ModuleOutputElement element,
                                      ArtifactCompilerInstructionCreator instructionCreator,
@@ -160,7 +191,11 @@ public class LayoutElementBuildersRegistry {
     }
   }
 
-  private static class ModuleTestOutputElementBuilder extends LayoutElementBuilder<ModuleTestOutputElement> {
+  private static class ModuleTestOutputElementBuilder extends LayoutElementBuilderService<ModuleTestOutputElement> {
+    public ModuleTestOutputElementBuilder() {
+      super(ModuleTestOutputElement.class);
+    }
+
     @Override
     public void generateInstructions(ModuleTestOutputElement element,
                                      ArtifactCompilerInstructionCreator instructionCreator,
@@ -169,7 +204,11 @@ public class LayoutElementBuildersRegistry {
     }
   }
 
-  private class ComplexElementBuilder extends LayoutElementBuilder<ComplexLayoutElement> {
+  private class ComplexElementBuilder extends LayoutElementBuilderService<ComplexLayoutElement> {
+    public ComplexElementBuilder() {
+      super(ComplexLayoutElement.class);
+    }
+
     @Override
     public void generateInstructions(ComplexLayoutElement element,
                                      ArtifactCompilerInstructionCreator instructionCreator,
@@ -178,7 +217,11 @@ public class LayoutElementBuildersRegistry {
     }
   }
 
-  private class ArtifactOutputElementBuilder extends LayoutElementBuilder<ArtifactLayoutElement> {
+  private class ArtifactOutputElementBuilder extends LayoutElementBuilderService<ArtifactLayoutElement> {
+    public ArtifactOutputElementBuilder() {
+      super(ArtifactLayoutElement.class);
+    }
+
     @Override
     public void generateInstructions(ArtifactLayoutElement element,
                                      ArtifactCompilerInstructionCreator instructionCreator,

jps/jps-builders/src/org/jetbrains/jps/incremental/artifacts/impl/JarsBuilder.java

@@ -303,7 +303,7 @@ public class JarsBuilder {
                                        @NotNull String relativePath,
                                        String targetJarPath, @NotNull Set<String> writtenItemRelativePaths, int rootIndex) throws IOException {
     final String filePath = FileUtil.toSystemIndependentName(file.getAbsolutePath());
-    if (!filter.accept(filePath)) {
+    if (!filter.accept(filePath, myContext.getDataManager())) {
       return;
     }
 

jps/jps-builders/src/org/jetbrains/jps/incremental/artifacts/instructions/ArtifactCompilerInstructionCreatorBase.java

@@ -22,8 +22,10 @@ import org.jetbrains.jps.IgnoredFilePatterns;
 import org.jetbrains.jps.PathUtil;
 import org.jetbrains.jps.incremental.ModuleRootsIndex;
 import org.jetbrains.jps.incremental.artifacts.JarPathUtil;
+import org.jetbrains.jps.incremental.storage.BuildDataManager;
 
 import java.io.File;
+import java.io.IOException;
 import java.util.List;
 
 /**
@@ -84,8 +86,8 @@ public abstract class ArtifactCompilerInstructionCreatorBase implements Artifact
     }
 
     @Override
-    public boolean accept(@NotNull String fullFilePath) {
-      if (myBaseFilter != null && !myBaseFilter.accept(fullFilePath)) return false;
+    public boolean accept(@NotNull String fullFilePath, BuildDataManager dataManager) throws IOException {
+      if (myBaseFilter != null && !myBaseFilter.accept(fullFilePath, dataManager)) return false;
 
       if (myIgnoredFilePatterns.isIgnored(PathUtil.getFileName(fullFilePath))) {
         return false;

jps/jps-builders/src/org/jetbrains/jps/incremental/artifacts/instructions/ArtifactSourceRoot.java

@@ -4,6 +4,7 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jps.incremental.CompileContext;
 import org.jetbrains.jps.incremental.artifacts.ArtifactOutputToSourceMapping;
 import org.jetbrains.jps.incremental.artifacts.ArtifactSourceToOutputMapping;
+import org.jetbrains.jps.incremental.storage.BuildDataManager;
 
 import java.io.File;
 import java.io.IOException;
@@ -21,7 +22,7 @@ public abstract class ArtifactSourceRoot {
   @NotNull
   public abstract File getRootFile();
 
-  public abstract boolean containsFile(String filePath);
+  public abstract boolean containsFile(String filePath, BuildDataManager dataManager) throws IOException;
 
   public abstract void copyFromRoot(String filePath,
                                     int rootIndex, String outputPath,

jps/jps-builders/src/org/jetbrains/jps/incremental/artifacts/instructions/FileBasedArtifactSourceRoot.java

@@ -6,6 +6,7 @@ import org.jetbrains.jps.PathUtil;
 import org.jetbrains.jps.incremental.CompileContext;
 import org.jetbrains.jps.incremental.artifacts.ArtifactOutputToSourceMapping;
 import org.jetbrains.jps.incremental.artifacts.ArtifactSourceToOutputMapping;
+import org.jetbrains.jps.incremental.storage.BuildDataManager;
 
 import java.io.File;
 import java.io.IOException;
@@ -29,8 +30,8 @@ public class FileBasedArtifactSourceRoot extends ArtifactSourceRoot {
   }
 
   @Override
-  public boolean containsFile(String filePath) {
-    return FileUtil.isAncestor(myFile, new File(FileUtil.toSystemDependentName(filePath)), false) && getFilter().accept(filePath);
+  public boolean containsFile(String filePath, BuildDataManager dataManager) throws IOException {
+    return FileUtil.isAncestor(myFile, new File(FileUtil.toSystemDependentName(filePath)), false) && getFilter().accept(filePath, dataManager);
   }
 
   @Override

jps/jps-builders/src/org/jetbrains/jps/incremental/artifacts/instructions/JarBasedArtifactSourceRoot.java

@@ -9,6 +9,7 @@ import org.jetbrains.jps.incremental.CompileContext;
 import org.jetbrains.jps.incremental.artifacts.ArtifactOutputToSourceMapping;
 import org.jetbrains.jps.incremental.artifacts.ArtifactSourceToOutputMapping;
 import org.jetbrains.jps.incremental.artifacts.JarPathUtil;
+import org.jetbrains.jps.incremental.storage.BuildDataManager;
 
 import java.io.*;
 import java.util.Collections;
@@ -36,7 +37,7 @@ public class JarBasedArtifactSourceRoot extends ArtifactSourceRoot {
   }
 
   @Override
-  public boolean containsFile(String filePath) {
+  public boolean containsFile(String filePath, BuildDataManager dataManager) {
     return new File(FileUtil.toSystemDependentName(filePath)).equals(myJarFile);
   }
 

jps/jps-builders/src/org/jetbrains/jps/incremental/artifacts/instructions/SourceFileFilter.java

@@ -1,6 +1,9 @@
 package org.jetbrains.jps.incremental.artifacts.instructions;
 
 import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jps.incremental.storage.BuildDataManager;
+
+import java.io.IOException;
 
 /**
  * @author nik
@@ -8,10 +11,10 @@ import org.jetbrains.annotations.NotNull;
 public abstract class SourceFileFilter {
   public static final SourceFileFilter ALL = new SourceFileFilter() {
     @Override
-    public boolean accept(@NotNull String fullFilePath) {
+    public boolean accept(@NotNull String fullFilePath, BuildDataManager dataManager) {
       return true;
     }
   };
 
-  public abstract boolean accept(@NotNull String fullFilePath);
+  public abstract boolean accept(@NotNull String fullFilePath, BuildDataManager dataManager) throws IOException;
 }

jps/jps-builders/testSrc/org/jetbrains/jps/incremental/artifacts/ArtifactBuilderTest.java

@@ -170,7 +170,7 @@ public class ArtifactBuilderTest extends ArtifactBuilderTestCase {
     final String excluded = PathUtil.getParentPath(file);
     final String dir = PathUtil.getParentPath(excluded);
 
-    final Module module = addModule("myModule", null);
+    final Module module = addModule("myModule");
     module.getContentRoots().add(dir);
     module.addExcludedRoot(excluded);
 
@@ -186,7 +186,7 @@ public class ArtifactBuilderTest extends ArtifactBuilderTestCase {
     createFile("xxx/CVS");
     final String dir = PathUtil.getParentPath(PathUtil.getParentPath(file));
 
-    Module module = addModule("myModule", null);
+    Module module = addModule("myModule");
     module.getContentRoots().add(dir);
     module.addExcludedRoot(PathUtil.getParentPath(file));
 

jps/jps-builders/testSrc/org/jetbrains/jps/incremental/artifacts/ArtifactBuilderTestCase.java

@@ -106,12 +106,16 @@ public abstract class ArtifactBuilderTestCase extends UsefulTestCase {
     artifact.setName(name);
     artifact.setRootElement(root.buildElement());
     
-    artifact.setOutputPath(FileUtil.toSystemIndependentName(new File(getOrCreateProjectDir(), "out/artifacts/" + name).getAbsolutePath()));
+    artifact.setOutputPath(getAbsolutePath("out/artifacts/" + name));
     myProject.getArtifacts().put(name, artifact);
     return artifact;
   }
 
-  protected Module addModule(String moduleName, @Nullable String srcPath) {
+  private String getAbsolutePath(final String pathRelativeToProjectRoot) {
+    return FileUtil.toSystemIndependentName(new File(getOrCreateProjectDir(), pathRelativeToProjectRoot).getAbsolutePath());
+  }
+
+  protected Module addModule(String moduleName, String... srcPaths) {
     if (myJdk == null) {
       try {
         myJdk = myProject.createSdk("JavaSDK", "jdk", "1.6", System.getProperty("java.home"), null);
@@ -127,10 +131,12 @@ public abstract class ArtifactBuilderTestCase extends UsefulTestCase {
     module.forceInit();
     module.setSdk(myJdk);
     module.addDependency(myJdk, PredefinedDependencyScopes.getCOMPILE(), false);
-    if (srcPath != null) {
-      module.getContentRoots().add(srcPath);
-      module.getSourceRoots().add(srcPath);
-      module.setOutputPath("out/production/" + moduleName);
+    if (srcPaths.length > 0) {
+      for (String srcPath : srcPaths) {
+        module.getContentRoots().add(srcPath);
+        module.getSourceRoots().add(srcPath);
+      }
+      module.setOutputPath(getAbsolutePath("out/production/" + moduleName));
     }
     return module;
   }

jps/jps-builders/testSrc/org/jetbrains/jps/incremental/artifacts/LayoutElementTestUtil.java

@@ -66,18 +66,20 @@ public class LayoutElementTestUtil {
     }
 
     public LayoutElementCreator fileCopy(String filePath, @Nullable String outputFileName) {
-      myElement.getChildren().add(new FileCopyElement(filePath, outputFileName));
-      return this;
+      return element(new FileCopyElement(filePath, outputFileName));
     }
 
     public LayoutElementCreator dirCopy(String dirPath) {
-      myElement.getChildren().add(new DirectoryCopyElement(dirPath));
-      return this;
+      return element(new DirectoryCopyElement(dirPath));
     }
 
     public LayoutElementCreator module(Module module) {
       final ModuleOutputElement element = new ModuleOutputElement();
       element.setModuleName(module.getName());
+      return element(element);
+    }
+
+    public LayoutElementCreator element(LayoutElement element) {
       myElement.getChildren().add(element);
       return this;
     }
@@ -86,23 +88,20 @@ public class LayoutElementTestUtil {
       final LibraryFilesElement element = new LibraryFilesElement();
       element.setLibraryName(library.getName());
       element.setLibraryLevel(LibraryFilesElement.PROJECT_LEVEL);
-      myElement.getChildren().add(element);
-      return this;
+      return element(element);
     }
 
     public LayoutElementCreator extractedDir(String jarPath, String pathInJar) {
       ExtractedDirectoryElement dir = new ExtractedDirectoryElement();
       dir.setJarPath(jarPath);
       dir.setPathInJar(pathInJar);
-      myElement.getChildren().add(dir);
-      return this;
+      return element(dir);
     }
 
     public LayoutElementCreator artifact(Artifact included) {
       final ArtifactLayoutElement element = new ArtifactLayoutElement();
       element.setArtifactName(included.getName());
-      myElement.getChildren().add(element);
-      return this;
+      return element(element);
     }
 
     public LayoutElementCreator end() {