maven: webapp resource filtering supported (IDEA-25934)

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

@@ -121,7 +121,7 @@ public class ArtifactBuildTarget extends BuildTarget<ArtifactRootDescriptor> {
                                                              ModuleExcludeIndex index,
                                                              IgnoredFileIndex ignoredFileIndex,
                                                              BuildDataPaths dataPaths) {
-    ArtifactInstructionsBuilderImpl builder = new ArtifactInstructionsBuilderImpl(index, ignoredFileIndex, this);
+    ArtifactInstructionsBuilderImpl builder = new ArtifactInstructionsBuilderImpl(index, ignoredFileIndex, this, model, dataPaths);
     ArtifactInstructionsBuilderContext context = new ArtifactInstructionsBuilderContextImpl(model, dataPaths);
     String outputPath = StringUtil.notNullize(myArtifact.getOutputPath());
     final CopyToDirectoryInstructionCreator instructionCreator = new CopyToDirectoryInstructionCreator(builder, outputPath);

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

@@ -17,9 +17,12 @@ package org.jetbrains.jps.incremental.artifacts.instructions;
 
 import com.intellij.openapi.util.Condition;
 import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jps.builders.storage.BuildDataPaths;
 import org.jetbrains.jps.incremental.artifacts.ArtifactBuildTarget;
 import org.jetbrains.jps.indices.IgnoredFileIndex;
 import org.jetbrains.jps.indices.ModuleExcludeIndex;
+import org.jetbrains.jps.model.JpsModel;
+import org.jetbrains.jps.service.JpsServiceManager;
 
 import java.io.File;
 import java.util.ArrayList;
@@ -34,16 +37,25 @@ public class ArtifactInstructionsBuilderImpl implements ArtifactInstructionsBuil
   private final Map<String, JarInfo> myJarByPath;
   private final List<ArtifactRootDescriptor> myDescriptors;
   private final ModuleExcludeIndex myRootsIndex;
+  private final Iterable<ArtifactRootCopyingHandlerProvider> myCopyingHandlerProviders;
   private int myRootIndex;
   private final IgnoredFileIndex myIgnoredFileIndex;
   private ArtifactBuildTarget myBuildTarget;
+  private final JpsModel myModel;
+  private final BuildDataPaths myBuildDataPaths;
 
-  public ArtifactInstructionsBuilderImpl(ModuleExcludeIndex rootsIndex, IgnoredFileIndex ignoredFileIndex, ArtifactBuildTarget target) {
+  public ArtifactInstructionsBuilderImpl(@NotNull ModuleExcludeIndex rootsIndex,
+                                         @NotNull IgnoredFileIndex ignoredFileIndex,
+                                         @NotNull ArtifactBuildTarget target,
+                                         @NotNull JpsModel model, @NotNull BuildDataPaths dataPaths) {
     myRootsIndex = rootsIndex;
     myIgnoredFileIndex = ignoredFileIndex;
     myBuildTarget = target;
+    myModel = model;
+    myBuildDataPaths = dataPaths;
     myJarByPath = new HashMap<String, JarInfo>();
     myDescriptors = new ArrayList<ArtifactRootDescriptor>();
+    myCopyingHandlerProviders = JpsServiceManager.getInstance().getExtensions(ArtifactRootCopyingHandlerProvider.class);
   }
 
   public IgnoredFileIndex getIgnoredFileIndex() {
@@ -74,8 +86,19 @@ public class ArtifactInstructionsBuilderImpl implements ArtifactInstructionsBuil
 
   public FileBasedArtifactRootDescriptor createFileBasedRoot(@NotNull File file,
                                                              @NotNull SourceFileFilter filter,
-                                                             final DestinationInfo destinationInfo) {
-    return new FileBasedArtifactRootDescriptor(file, filter, myRootIndex++, myBuildTarget, destinationInfo);
+                                                             final @NotNull DestinationInfo destinationInfo) {
+    FileCopyingHandler handler = createCopyingHandler(file);
+    return new FileBasedArtifactRootDescriptor(file, filter, myRootIndex++, myBuildTarget, destinationInfo, handler);
+  }
+
+  private FileCopyingHandler createCopyingHandler(File file) {
+    for (ArtifactRootCopyingHandlerProvider provider : myCopyingHandlerProviders) {
+      FileCopyingHandler handler = provider.createCustomHandler(myBuildTarget.getArtifact(), file, myModel, myBuildDataPaths);
+      if (handler != null) {
+        return handler;
+      }
+    }
+    return FileCopyingHandler.DEFAULT;
   }
 
   public JarBasedArtifactRootDescriptor createJarBasedRoot(@NotNull File jarFile,

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

@@ -0,0 +1,33 @@
+/*
+ * Copyright 2000-2014 JetBrains s.r.o.
+ *
+ * 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.
+ */
+package org.jetbrains.jps.incremental.artifacts.instructions;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import org.jetbrains.jps.builders.storage.BuildDataPaths;
+import org.jetbrains.jps.model.JpsModel;
+import org.jetbrains.jps.model.artifact.JpsArtifact;
+
+import java.io.File;
+
+/**
+ * @author nik
+ */
+public abstract class ArtifactRootCopyingHandlerProvider {
+  @Nullable
+  public abstract FileCopyingHandler createCustomHandler(@NotNull JpsArtifact artifact, @NotNull File root, @NotNull JpsModel model,
+                                                         @NotNull BuildDataPaths buildDataPaths);
+}

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

@@ -17,9 +17,11 @@ package org.jetbrains.jps.incremental.artifacts.instructions;
 
 import com.intellij.openapi.diagnostic.Logger;
 import com.intellij.openapi.util.io.FileUtil;
+import com.intellij.openapi.util.io.FileUtilRt;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jps.builders.BuildOutputConsumer;
 import org.jetbrains.jps.builders.logging.ProjectBuilderLogger;
+import org.jetbrains.jps.cmdline.ProjectDescriptor;
 import org.jetbrains.jps.incremental.CompileContext;
 import org.jetbrains.jps.incremental.ProjectBuildException;
 import org.jetbrains.jps.incremental.artifacts.ArtifactBuildTarget;
@@ -28,7 +30,9 @@ import org.jetbrains.jps.incremental.artifacts.IncArtifactBuilder;
 import org.jetbrains.jps.incremental.artifacts.impl.JpsArtifactPathUtil;
 
 import java.io.File;
+import java.io.FileFilter;
 import java.io.IOException;
+import java.io.PrintWriter;
 import java.util.Collections;
 
 /**
@@ -36,12 +40,21 @@ import java.util.Collections;
  */
 public class FileBasedArtifactRootDescriptor extends ArtifactRootDescriptor {
   private static final Logger LOG = Logger.getInstance(FileBasedArtifactRootDescriptor.class);
+  private FileCopyingHandler myCopyingHandler;
+
   public FileBasedArtifactRootDescriptor(@NotNull File file,
                                          @NotNull SourceFileFilter filter,
                                          int index,
                                          ArtifactBuildTarget target,
-                                         @NotNull DestinationInfo destinationInfo) {
-    super(file, filter, index, target, destinationInfo);
+                                         @NotNull DestinationInfo destinationInfo, FileCopyingHandler copyingHandler) {
+    super(file, createCompositeFilter(filter, copyingHandler.createFileFilter()), index, target, destinationInfo);
+    myCopyingHandler = copyingHandler;
+  }
+
+  @NotNull
+  private static SourceFileFilter createCompositeFilter(@NotNull final SourceFileFilter baseFilter, @NotNull final FileFilter filter) {
+    if (filter.equals(FileUtilRt.ALL_FILES)) return baseFilter;
+    return new CompositeSourceFileFilter(baseFilter, filter);
   }
 
   @Override
@@ -49,6 +62,12 @@ public class FileBasedArtifactRootDescriptor extends ArtifactRootDescriptor {
     return myRoot.getPath();
   }
 
+  @Override
+  public void writeConfiguration(PrintWriter out) {
+    super.writeConfiguration(out);
+    myCopyingHandler.writeConfiguration(out);
+  }
+
   public void copyFromRoot(String filePath,
                            int rootIndex, String outputPath,
                            CompileContext context, BuildOutputConsumer outputConsumer,
@@ -78,7 +97,7 @@ public class FileBasedArtifactRootDescriptor extends ArtifactRootDescriptor {
       if (logger.isEnabled()) {
         logger.logCompiledFiles(Collections.singletonList(file), IncArtifactBuilder.BUILDER_NAME, "Copying file:");
       }
-      FileUtil.copyContent(file, targetFile);
+      myCopyingHandler.copyFile(file, targetFile, context);
       outputConsumer.registerOutputFile(targetFile, Collections.singletonList(filePath));
     }
     else if (LOG.isDebugEnabled()) {
@@ -86,4 +105,24 @@ public class FileBasedArtifactRootDescriptor extends ArtifactRootDescriptor {
     }
     outSrcMapping.appendData(targetPath, rootIndex, filePath);
   }
+
+  private static class CompositeSourceFileFilter extends SourceFileFilter {
+    private final SourceFileFilter myBaseFilter;
+    private final FileFilter myFilter;
+
+    public CompositeSourceFileFilter(SourceFileFilter baseFilter, FileFilter filter) {
+      myBaseFilter = baseFilter;
+      myFilter = filter;
+    }
+
+    @Override
+    public boolean accept(@NotNull String fullFilePath) {
+      return myFilter.accept(new File(fullFilePath)) && myBaseFilter.accept(fullFilePath);
+    }
+
+    @Override
+    public boolean shouldBeCopied(@NotNull String fullFilePath, ProjectDescriptor projectDescriptor) throws IOException {
+      return myBaseFilter.shouldBeCopied(fullFilePath, projectDescriptor);
+    }
+  }
 }

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

@@ -0,0 +1,51 @@
+/*
+ * Copyright 2000-2014 JetBrains s.r.o.
+ *
+ * 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.
+ */
+package org.jetbrains.jps.incremental.artifacts.instructions;
+
+import com.intellij.openapi.util.io.FileUtil;
+import com.intellij.openapi.util.io.FileUtilRt;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jps.incremental.CompileContext;
+
+import java.io.File;
+import java.io.FileFilter;
+import java.io.IOException;
+import java.io.PrintWriter;
+
+/**
+ * @author nik
+ */
+public abstract class FileCopyingHandler {
+  public static final FileCopyingHandler DEFAULT = new FileCopyingHandler() {
+    @Override
+    public void copyFile(@NotNull File from, @NotNull File to, @NotNull CompileContext context) throws IOException {
+      FileUtil.copyContent(from, to);
+    }
+
+    @Override
+    public void writeConfiguration(@NotNull PrintWriter out) {
+    }
+  };
+
+  public abstract void copyFile(@NotNull File from, @NotNull File to, @NotNull CompileContext context) throws IOException;
+
+  public abstract void writeConfiguration(@NotNull PrintWriter out);
+
+  @NotNull
+  public FileFilter createFileFilter() {
+    return FileUtilRt.ALL_FILES;
+  }
+}

plugins/maven/jps-plugin/src/META-INF/services/org.jetbrains.jps.incremental.artifacts.instructions.ArtifactRootCopyingHandlerProvider

@@ -0,0 +1 @@
+org.jetbrains.jps.maven.compiler.MavenWebArtifactRootCopyingHandlerProvider

plugins/maven/jps-plugin/src/org/jetbrains/jps/maven/compiler/MavenResourceFileProcessor.java

@@ -26,7 +26,9 @@ import org.jetbrains.jps.incremental.messages.CompilerMessage;
 import org.jetbrains.jps.maven.model.impl.MavenModuleResourceConfiguration;
 import org.jetbrains.jps.maven.model.impl.MavenProjectConfiguration;
 import org.jetbrains.jps.maven.model.impl.ResourceRootConfiguration;
+import org.jetbrains.jps.model.JpsEncodingConfigurationService;
 import org.jetbrains.jps.model.JpsEncodingProjectConfiguration;
+import org.jetbrains.jps.model.JpsProject;
 
 import java.io.File;
 import java.io.FileNotFoundException;
@@ -55,12 +57,11 @@ public class MavenResourceFileProcessor {
   private Map<String, String> myProperties;
   private Pattern myDelimitersPattern;
 
-  public MavenResourceFileProcessor(MavenProjectConfiguration projectConfiguration,
-                                    JpsEncodingProjectConfiguration encodingConfiguration,
+  public MavenResourceFileProcessor(MavenProjectConfiguration projectConfiguration, JpsProject project,
                                     MavenModuleResourceConfiguration moduleConfiguration) {
     myTimestamp = new Date();
     myProjectConfig = projectConfiguration;
-    myEncodingConfig = encodingConfiguration;
+    myEncodingConfig = JpsEncodingConfigurationService.getInstance().getEncodingConfiguration(project);
     myModuleConfiguration = moduleConfiguration;
     myFilteringExcludedExtensions = moduleConfiguration.getFilteringExcludedExtensions();
   }

plugins/maven/jps-plugin/src/org/jetbrains/jps/maven/compiler/MavenResourcesBuilder.java

@@ -14,11 +14,12 @@ import org.jetbrains.jps.incremental.messages.CompilerMessage;
 import org.jetbrains.jps.incremental.messages.ProgressMessage;
 import org.jetbrains.jps.maven.model.JpsMavenExtensionService;
 import org.jetbrains.jps.maven.model.impl.*;
-import org.jetbrains.jps.model.JpsEncodingConfigurationService;
-import org.jetbrains.jps.model.JpsEncodingProjectConfiguration;
 
-import java.io.*;
-import java.util.*;
+import java.io.File;
+import java.io.IOException;
+import java.io.UnsupportedEncodingException;
+import java.util.Arrays;
+import java.util.Collections;
 
 /**
  * @author Eugene Zhuravlev
@@ -39,10 +40,8 @@ public class MavenResourcesBuilder extends TargetBuilder<MavenResourceRootDescri
     if (config == null) {
       return;
     }
-    final JpsEncodingProjectConfiguration encodingConfig =
-      JpsEncodingConfigurationService.getInstance().getEncodingConfiguration(target.getModule().getProject());
 
-    final MavenResourceFileProcessor fileProcessor = new MavenResourceFileProcessor(projectConfig, encodingConfig, config);
+    final MavenResourceFileProcessor fileProcessor = new MavenResourceFileProcessor(projectConfig, target.getModule().getProject(), config);
     holder.processDirtyFiles(new FileProcessor<MavenResourceRootDescriptor, MavenResourcesTarget>() {
 
       @Override

plugins/maven/jps-plugin/src/org/jetbrains/jps/maven/compiler/MavenWebArtifactRootCopyingHandlerProvider.java

@@ -0,0 +1,97 @@
+/*
+ * Copyright 2000-2014 JetBrains s.r.o.
+ *
+ * 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.
+ */
+package org.jetbrains.jps.maven.compiler;
+
+import com.intellij.openapi.diagnostic.Logger;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import org.jetbrains.jps.builders.storage.BuildDataPaths;
+import org.jetbrains.jps.incremental.CompileContext;
+import org.jetbrains.jps.incremental.artifacts.instructions.ArtifactRootCopyingHandlerProvider;
+import org.jetbrains.jps.incremental.artifacts.instructions.FileCopyingHandler;
+import org.jetbrains.jps.maven.model.JpsMavenExtensionService;
+import org.jetbrains.jps.maven.model.impl.*;
+import org.jetbrains.jps.model.JpsModel;
+import org.jetbrains.jps.model.artifact.JpsArtifact;
+
+import java.io.File;
+import java.io.FileFilter;
+import java.io.IOException;
+import java.io.PrintWriter;
+
+/**
+ * @author nik
+ */
+public class MavenWebArtifactRootCopyingHandlerProvider extends ArtifactRootCopyingHandlerProvider {
+  private static final Logger LOG = Logger.getInstance(MavenWebArtifactRootCopyingHandlerProvider.class);
+  @Nullable
+  @Override
+  public FileCopyingHandler createCustomHandler(@NotNull JpsArtifact artifact, @NotNull File root, @NotNull JpsModel model,
+                                                @NotNull BuildDataPaths buildDataPaths) {
+    JpsMavenExtensionService mavenExtensionService = JpsMavenExtensionService.getInstance();
+    if (!mavenExtensionService.hasMavenProjectConfiguration(buildDataPaths)) return null;
+
+    MavenProjectConfiguration projectConfiguration = mavenExtensionService.getMavenProjectConfiguration(buildDataPaths);
+    MavenArtifactResourceConfiguration artifactResourceConfiguration = projectConfiguration.artifactsResources.get(artifact.getName());
+    if (artifactResourceConfiguration == null) return null;
+
+    ResourceRootConfiguration rootConfiguration = artifactResourceConfiguration.getRootConfiguration(root);
+    if (rootConfiguration == null) return null;
+
+    MavenModuleResourceConfiguration moduleResourceConfiguration = projectConfiguration.moduleConfigurations.get(artifactResourceConfiguration.moduleName);
+    if (moduleResourceConfiguration == null) {
+      LOG.debug("Maven resource configuration not found for module " + artifactResourceConfiguration.moduleName);
+      return null;
+    }
+
+    MavenResourceFileProcessor fileProcessor = new MavenResourceFileProcessor(projectConfiguration, model.getProject(), moduleResourceConfiguration);
+    return new MavenWebRootCopyingHandler(fileProcessor, rootConfiguration, moduleResourceConfiguration, root);
+  }
+
+  private static class MavenWebRootCopyingHandler extends FileCopyingHandler {
+    private final MavenResourceFileProcessor myFileProcessor;
+    @NotNull private final ResourceRootConfiguration myRootConfiguration;
+    @NotNull private final MavenModuleResourceConfiguration myModuleResourceConfiguration;
+    @NotNull private final File myRoot;
+
+    private MavenWebRootCopyingHandler(@NotNull MavenResourceFileProcessor fileProcessor,
+                                       @NotNull ResourceRootConfiguration rootConfiguration,
+                                       @NotNull MavenModuleResourceConfiguration moduleResourceConfiguration,
+                                       @NotNull File root) {
+      myFileProcessor = fileProcessor;
+      myRootConfiguration = rootConfiguration;
+      myModuleResourceConfiguration = moduleResourceConfiguration;
+      myRoot = root;
+    }
+
+    @Override
+    public void copyFile(@NotNull File from, @NotNull File to, @NotNull CompileContext context) throws IOException {
+      myFileProcessor.copyFile(from, to, myRootConfiguration, context);
+    }
+
+    @Override
+    public void writeConfiguration(@NotNull PrintWriter out) {
+      out.print("maven hash:");
+      out.println(myModuleResourceConfiguration.computeModuleConfigurationHash() + 31*myRootConfiguration.computeConfigurationHash());
+    }
+
+    @NotNull
+    @Override
+    public FileFilter createFileFilter() {
+      return new MavenResourceFileFilter(myRoot, myRootConfiguration);
+    }
+  }
+}

plugins/maven/jps-plugin/src/org/jetbrains/jps/maven/model/JpsMavenExtensionService.java

@@ -26,6 +26,8 @@ public abstract class JpsMavenExtensionService {
 
   public abstract boolean isProductionOnTestDependency(@NotNull JpsDependencyElement dependency);
 
+  public abstract boolean hasMavenProjectConfiguration(@NotNull BuildDataPaths paths);
+
   @NotNull
   public abstract MavenProjectConfiguration getMavenProjectConfiguration(BuildDataPaths paths);
 }

plugins/maven/jps-plugin/src/org/jetbrains/jps/maven/model/impl/JpsMavenExtensionServiceImpl.java

@@ -2,6 +2,9 @@ package org.jetbrains.jps.maven.model.impl;
 
 import com.intellij.openapi.diagnostic.Logger;
 import com.intellij.openapi.util.JDOMUtil;
+import com.intellij.openapi.util.io.FileUtil;
+import com.intellij.util.containers.ConcurrentFactoryMap;
+import com.intellij.util.containers.FactoryMap;
 import com.intellij.util.xmlb.XmlSerializer;
 import gnu.trove.THashMap;
 import org.jdom.Document;
@@ -28,6 +31,15 @@ import java.util.Map;
 public class JpsMavenExtensionServiceImpl extends JpsMavenExtensionService {
   private static final Logger LOG = Logger.getInstance("#org.jetbrains.jps.maven.model.impl.JpsMavenExtensionServiceImpl");
   private static final JpsElementChildRole<JpsSimpleElement<Boolean>> PRODUCTION_ON_TEST_ROLE = JpsElementChildRoleBase.create("production on test");
+  private final Map<File, MavenProjectConfiguration> myLoadedConfigs =
+    new THashMap<File, MavenProjectConfiguration>(FileUtil.FILE_HASHING_STRATEGY);
+  private final FactoryMap<File, Boolean> myConfigFileExists = new ConcurrentFactoryMap<File, Boolean>() {
+    @Nullable
+    @Override
+    protected Boolean create(File key) {
+      return key.exists();
+    }
+  };
 
   public JpsMavenExtensionServiceImpl() {
     ResourcesBuilder.registerEnabler(new StandardResourceBuilderEnabler() {
@@ -73,7 +85,10 @@ public class JpsMavenExtensionServiceImpl extends JpsMavenExtensionService {
     return child != null && child.getData();
   }
 
-  private final Map<File, MavenProjectConfiguration> myLoadedConfigs = new THashMap<File, MavenProjectConfiguration>();
+  @Override
+  public boolean hasMavenProjectConfiguration(@NotNull BuildDataPaths paths) {
+    return myConfigFileExists.get(new File(paths.getDataStorageRoot(), MavenProjectConfiguration.CONFIGURATION_FILE_RELATIVE_PATH));
+  }
 
   @NotNull
   @Override

plugins/maven/jps-plugin/src/org/jetbrains/jps/maven/model/impl/MavenArtifactResourceConfiguration.java

@@ -15,21 +15,45 @@
  */
 package org.jetbrains.jps.maven.model.impl;
 
+import com.intellij.openapi.util.io.FileUtil;
 import com.intellij.util.xmlb.annotations.AbstractCollection;
 import com.intellij.util.xmlb.annotations.Tag;
+import com.intellij.util.xmlb.annotations.Transient;
+import gnu.trove.THashMap;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
 
+import java.io.File;
 import java.util.ArrayList;
 import java.util.List;
+import java.util.Map;
 
 /**
  * @author Sergey Evdokimov
  */
 public class MavenArtifactResourceConfiguration {
-
+  @Tag("web-artifact-name")
   public String webArtifactName;
 
+  @Tag("module-name")
+  public String moduleName;
+
   @Tag("web-resources")
   @AbstractCollection(surroundWithTag = false, elementTag = "resource")
   public List<ResourceRootConfiguration> webResources = new ArrayList<ResourceRootConfiguration>();
 
+  @Transient
+  private volatile Map<File, ResourceRootConfiguration> myResourceRootsMap;
+
+  @Nullable
+  public ResourceRootConfiguration getRootConfiguration(@NotNull File root) {
+    if (myResourceRootsMap == null) {
+      Map<File, ResourceRootConfiguration> map = new THashMap<File, ResourceRootConfiguration>(FileUtil.FILE_HASHING_STRATEGY);
+      for (ResourceRootConfiguration resource : webResources) {
+        map.put(new File(resource.directory), resource);
+      }
+      myResourceRootsMap = map;
+    }
+    return myResourceRootsMap.get(root);
+  }
 }

plugins/maven/jps-plugin/src/org/jetbrains/jps/maven/model/impl/MavenModuleResourceConfiguration.java

@@ -82,15 +82,7 @@ public class MavenModuleResourceConfiguration {
   }
 
   public int computeConfigurationHash(boolean forTestResources) {
-    int result = id.hashCode();
-    result = 31 * result + (parentId != null ? parentId.hashCode() : 0);
-    result = 31 * result + directory.hashCode();
-    result = 31 * result + delimitersPattern.hashCode();
-    result = 31 * result + modelMap.hashCode();
-    result = 31 * result + properties.hashCode();
-    result = 31 * result + filteringExclusions.hashCode();
-    result = 31 * result + (escapeString != null ? escapeString.hashCode() : 0);
-    result = 31 * result + (escapeWindowsPaths ? 1 : 0);
+    int result = computeModuleConfigurationHash();
 
     final List<ResourceRootConfiguration> _resources = forTestResources? testResources : resources;
     result = 31 * result;
@@ -100,6 +92,18 @@ public class MavenModuleResourceConfiguration {
     return result;
   }
 
+  public int computeModuleConfigurationHash() {
+    int result = id.hashCode();
+    result = 31 * result + (parentId != null ? parentId.hashCode() : 0);
+    result = 31 * result + directory.hashCode();
+    result = 31 * result + delimitersPattern.hashCode();
+    result = 31 * result + modelMap.hashCode();
+    result = 31 * result + properties.hashCode();
+    result = 31 * result + filteringExclusions.hashCode();
+    result = 31 * result + (escapeString != null ? escapeString.hashCode() : 0);
+    result = 31 * result + (escapeWindowsPaths ? 1 : 0);
+    return result;
+  }
 }
 
 

plugins/maven/src/main/java/org/jetbrains/idea/maven/project/MavenResourceCompilerConfigurationGenerator.java

@@ -238,6 +238,7 @@ public class MavenResourceCompilerConfigurationGenerator {
     if (artifactResourceCfg == null) {
       artifactResourceCfg = new MavenArtifactResourceConfiguration();
       artifactResourceCfg.webArtifactName = webArtifactName;
+      artifactResourceCfg.moduleName = module.getName();
       projectCfg.artifactsResources.put(webArtifactName, artifactResourceCfg);
     }
     else {

plugins/maven/src/test/java/org/jetbrains/idea/maven/compiler/MavenCompilingTestCase.java

@@ -17,6 +17,7 @@ package org.jetbrains.idea.maven.compiler;
 
 import com.intellij.compiler.CompilerManagerImpl;
 import com.intellij.compiler.CompilerWorkspaceConfiguration;
+import com.intellij.compiler.artifacts.ArtifactsTestUtil;
 import com.intellij.compiler.impl.ModuleCompileScope;
 import com.intellij.compiler.impl.TranslatingCompilerFilesMonitor;
 import com.intellij.openapi.compiler.CompileContext;
@@ -27,7 +28,10 @@ import com.intellij.openapi.module.Module;
 import com.intellij.openapi.roots.ProjectRootManager;
 import com.intellij.openapi.util.io.FileUtil;
 import com.intellij.openapi.vfs.VirtualFile;
+import com.intellij.packaging.artifacts.Artifact;
+import com.intellij.packaging.impl.compiler.ArtifactCompileScope;
 import com.intellij.util.concurrency.Semaphore;
+import com.intellij.util.io.TestFileSystemBuilder;
 import com.intellij.util.ui.UIUtil;
 import org.jetbrains.idea.maven.MavenImportingTestCase;
 import org.jetbrains.idea.maven.project.MavenProjectsManager;
@@ -44,15 +48,20 @@ import java.util.List;
  * @author nik
  */
 public abstract class MavenCompilingTestCase extends MavenImportingTestCase {
-  protected void compileModules(final String... moduleNames) throws Exception {
-    final List<Module> modules = new ArrayList<Module>();
+  protected void compileModules(final String... moduleNames) {
+    compile(createModulesCompileScope(moduleNames));
+  }
 
+  protected void buildArtifacts(String... artifactNames) {
+    compile(createArtifactsScope(artifactNames));
+  }
+
+  private void compile(final CompileScope scope) {
     UIUtil.invokeAndWaitIfNeeded(new Runnable() {
       @Override
       public void run() {
-        for (String each : moduleNames) {
-          setupJdkForModule(each);
-          modules.add(getModule(each));
+        for (Module module : scope.getAffectedModules()) {
+          setupJdkForModule(module.getName());
         }
         if (useJps()) {
           new MavenResourceCompilerConfigurationGenerator(myProject, MavenProjectsManager.getInstance(myProject).getProjectsTreeForTests())
@@ -68,7 +77,6 @@ public abstract class MavenCompilingTestCase extends MavenImportingTestCase {
     TranslatingCompilerFilesMonitor.getInstance()
       .scanSourceContent(new TranslatingCompilerFilesMonitor.ProjectRef(myProject), roots, roots.size(), true);
 
-    final CompileScope scope = new ModuleCompileScope(myProject, modules.toArray(new Module[modules.size()]), false);
 
     final Semaphore semaphore = new Semaphore();
     semaphore.down();
@@ -96,6 +104,22 @@ public abstract class MavenCompilingTestCase extends MavenImportingTestCase {
     }
   }
 
+  private CompileScope createArtifactsScope(String[] artifactNames) {
+    List<Artifact> artifacts = new ArrayList<Artifact>();
+    for (String name : artifactNames) {
+      artifacts.add(ArtifactsTestUtil.findArtifact(myProject, name));
+    }
+    return ArtifactCompileScope.createArtifactsScope(myProject, artifacts);
+  }
+
+  private CompileScope createModulesCompileScope(final String[] moduleNames) {
+    final List<Module> modules = new ArrayList<Module>();
+    for (String name : moduleNames) {
+      modules.add(getModule(name));
+    }
+    return new ModuleCompileScope(myProject, modules.toArray(new Module[modules.size()]), false);
+  }
+
   protected static void assertResult(VirtualFile pomFile, String relativePath, String content) throws IOException {
     assertEquals(content, loadResult(pomFile, relativePath));
   }
@@ -109,4 +133,8 @@ public abstract class MavenCompilingTestCase extends MavenImportingTestCase {
   protected void assertResult(String relativePath, String content) throws IOException {
     assertResult(myProjectPom, relativePath, content);
   }
+
+  protected void assertDirectory(String relativePath, TestFileSystemBuilder fileSystemBuilder) {
+    fileSystemBuilder.build().assertDirectoryEqual(new File(myProjectPom.getParent().getPath(), relativePath));
+  }
 }