Minor rebar and eunit integration improvements

jps-plugin/src/org/intellij/erlang/jps/model/ErlangCompilerOptions.java

@@ -29,6 +29,7 @@ public ErlangCompilerOptions() {
   public ErlangCompilerOptions(ErlangCompilerOptions options) {
     myUseRebarCompiler = options.myUseRebarCompiler;
     myAddDebugInfoEnabled = options.myAddDebugInfoEnabled;
+    myCustomRebarConfig = options.myCustomRebarConfig;
   }
 
   @Tag("useRebarCompiler")
@@ -37,6 +38,12 @@ public ErlangCompilerOptions(ErlangCompilerOptions options) {
   @Tag("useDebugInfo")
   public boolean myAddDebugInfoEnabled = true;
 
+  @Tag("customRebarConfig")
+  public String myCustomRebarConfig = "";
+
+  @Tag("customEunitRebarConfig")
+  public String myCustomEunitRebarConfig = "";
+
   @Tag("additionalErlcArguments")
   @AbstractCollection(elementTag = "arg", elementTypes = String.class)
   public List<String> myAdditionalErlcArguments = ContainerUtil.newArrayList();

jps-plugin/src/org/intellij/erlang/jps/rebar/RebarBuilder.java

@@ -40,13 +40,18 @@
 
 import java.io.File;
 import java.io.IOException;
+import java.net.MalformedURLException;
+import java.net.URI;
+import java.net.URISyntaxException;
 import java.net.URL;
 import java.nio.charset.Charset;
+import java.nio.file.Paths;
 import java.util.Collections;
 
 public class RebarBuilder extends TargetBuilder<ErlangSourceRootDescriptor, ErlangTarget> {
   private static final String NAME = "rebar";
   private static final String REBAR_CONFIG_FILE_NAME = "rebar.config";
+  private static final String REBAR_CONFIG_SCRIPT_SUFFIX = ".script";
 
   public RebarBuilder() {
     super(Collections.singleton(ErlangTargetType.INSTANCE));
@@ -57,7 +62,7 @@ public void build(@NotNull ErlangTarget target,
                     @NotNull DirtyFilesHolder<ErlangSourceRootDescriptor, ErlangTarget> holder,
                     @NotNull BuildOutputConsumer outputConsumer,
                     @NotNull CompileContext context) throws ProjectBuildException, IOException {
-    if (!holder.hasDirtyFiles() && !holder.hasRemovedFiles()) return;
+    // Do not check for dirty files, delegate it to rebar
 
     JpsModule module = target.getModule();
     JpsProject project = module.getProject();
@@ -73,13 +78,17 @@ public void build(@NotNull ErlangTarget target,
 
     JpsSdk<JpsDummyElement> sdk = ErlangTargetBuilderUtil.getSdk(context, module);
     String escriptPath = JpsErlangSdkType.getScriptInterpreterExecutable(sdk.getHomePath()).getAbsolutePath();
+    String customRebarConfig = StringUtil.isEmptyOrSpaces(compilerOptions.myCustomRebarConfig) ? null : compilerOptions.myCustomRebarConfig;
+    String customEunitRebarConfig = StringUtil.isEmptyOrSpaces(compilerOptions.myCustomEunitRebarConfig) ? customRebarConfig : compilerOptions.myCustomEunitRebarConfig;
+    boolean isForcedBuild = context.getScope().isBuildForced(target);
     boolean isRebarRun = false;
     for (String contentRootUrl : module.getContentRootsList().getUrls()) {
-      String contentRootPath = new URL(contentRootUrl).getPath();
-      File contentRootDir = new File(contentRootPath);
-      File rebarConfigFile = new File(contentRootDir, REBAR_CONFIG_FILE_NAME);
-      if (!rebarConfigFile.exists()) continue;
-      runRebar(escriptPath, rebarPath, contentRootPath, compilerOptions.myAddDebugInfoEnabled, context);
+      String contentRootPath = getPathFromURL(contentRootUrl);
+      if (customRebarConfig == null) {
+        if (!isRebarConfigExists(contentRootPath, REBAR_CONFIG_FILE_NAME)) continue;
+      }
+      runRebar(escriptPath, rebarPath, contentRootPath, customRebarConfig, false, compilerOptions.myAddDebugInfoEnabled, isForcedBuild, context);
+      runRebar(escriptPath, rebarPath, contentRootPath, customEunitRebarConfig, true, true, isForcedBuild, context);
       isRebarRun = true;
     }
     if (!isRebarRun) {
@@ -97,13 +106,35 @@ public String getPresentableName() {
   private static void runRebar(@NotNull String escriptPath,
                                @NotNull String rebarPath,
                                @Nullable String contentRootPath,
+                               @Nullable String customRebarConfig,
+                               boolean isTest,
                                boolean addDebugInfo,
+                               boolean isForcedBuild,
                                @NotNull CompileContext context) throws ProjectBuildException {
     GeneralCommandLine commandLine = new GeneralCommandLine();
     commandLine.withWorkDirectory(contentRootPath);
     commandLine.setExePath(escriptPath);
     commandLine.addParameter(rebarPath);
-    commandLine.addParameter("compile");
+
+    if (isForcedBuild) {
+      commandLine.addParameter("clean");
+    }
+
+    if (isTest) {
+      commandLine.addParameter("eunit");
+      commandLine.addParameter("compile_only=true");
+    } else {
+      commandLine.addParameter("compile");
+    }
+
+    if (customRebarConfig != null) {
+      if (!isRebarConfigExists(contentRootPath, customRebarConfig)) {
+        throw new ProjectBuildException("Custom rebar config file is not found: '" + customRebarConfig + "'");
+      }
+
+      commandLine.addParameter("-C");
+      commandLine.addParameter(customRebarConfig);
+    }
 
     if (addDebugInfo) {
       commandLine.getEnvironment().put("ERL_FLAGS", "+debug_info");
@@ -126,6 +157,38 @@ private static void runRebar(@NotNull String escriptPath,
     }
   }
 
+  private static boolean isRebarConfigExists(@Nullable String contentRootDir, String rebarConfigPath) {
+    return isFileExists(contentRootDir, rebarConfigPath) ||
+            isFileExists(contentRootDir, rebarConfigPath + REBAR_CONFIG_SCRIPT_SUFFIX);
+  }
+
+  private static boolean isFileExists(@Nullable String baseDir, String filePath) {
+    File file = new File(filePath);
+    File absoluteFile;
+    if (baseDir == null || file.isAbsolute()) {
+      absoluteFile = file;
+    } else {
+      absoluteFile = new File(baseDir, filePath);
+    }
+
+    return absoluteFile.exists();
+  }
+
+  @Nullable
+  private static String getPathFromURL(String url) {
+    try {
+      URI uri = new URL(url).toURI();
+      String authority = uri.getAuthority();
+      if (!authority.isEmpty()) {
+        // Workaround for Windows UNC urls like file://C:/...
+        uri = new URI("file:///" + authority + uri.getPath());
+      }
+      return Paths.get(uri).toString();
+    } catch (URISyntaxException | MalformedURLException ignored) {
+      return null;
+    }
+  }
+
   @Nullable
   private static String getRebarExecutablePath(@Nullable JpsProject project) {
     JpsRebarConfigurationExtension rebarConfigurationExtension = JpsRebarConfigurationExtension.getExtension(project);

src/org/intellij/erlang/application/ErlangApplicationConfiguration.java

@@ -64,6 +64,11 @@ public boolean isUseTestCodePath() {
     return myUseTestCodePath;
   }
 
+  @Override
+  public boolean isUseRebarPaths() {
+    return false;
+  }
+
   public void setUseTestCodePath(boolean useTestCodePath) {
     myUseTestCodePath = useTestCodePath;
   }

src/org/intellij/erlang/application/ErlangApplicationRunningState.java

@@ -43,6 +43,11 @@ protected boolean useTestCodePath() {
     return myConfiguration.isUseTestCodePath();
   }
 
+  @Override
+  protected boolean useRebarOutputPaths() {
+    return false;
+  }
+
   @Override
   protected boolean isNoShellMode() {
     return true;

src/org/intellij/erlang/configuration/ErlangCompilerOptionsConfigurable.form

@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <form xmlns="http://www.intellij.com/uidesigner/form/" version="1" bind-to-class="org.intellij.erlang.configuration.ErlangCompilerOptionsConfigurable">
-  <grid id="27dc6" binding="myRootPanel" layout-manager="GridLayoutManager" row-count="4" column-count="2" same-size-horizontally="false" same-size-vertically="false" hgap="-1" vgap="-1">
+  <grid id="27dc6" binding="myRootPanel" layout-manager="GridLayoutManager" row-count="6" column-count="2" same-size-horizontally="false" same-size-vertically="false" hgap="-1" vgap="-1">
     <margin top="0" left="0" bottom="0" right="0"/>
     <constraints>
       <xy x="20" y="20" width="500" height="400"/>
@@ -23,7 +23,7 @@
       </component>
       <vspacer id="41a3d">
         <constraints>
-          <grid row="3" column="0" row-span="1" col-span="2" vsize-policy="6" hsize-policy="1" anchor="0" fill="2" indent="0" use-parent-layout="false"/>
+          <grid row="5" column="0" row-span="1" col-span="2" vsize-policy="6" hsize-policy="1" anchor="0" fill="2" indent="0" use-parent-layout="false"/>
         </constraints>
       </vspacer>
       <component id="c5f5e" class="javax.swing.JButton" binding="myConfigureRebarButton">
@@ -57,6 +57,34 @@
           <text value="Additional 'erlc' ar&amp;guments:"/>
         </properties>
       </component>
+      <component id="85a7e" class="javax.swing.JLabel" binding="myCustomRebarConfigLabel">
+        <constraints>
+          <grid row="3" column="0" row-span="1" col-span="1" vsize-policy="0" hsize-policy="0" anchor="8" fill="0" indent="0" use-parent-layout="false"/>
+        </constraints>
+        <properties>
+          <text value="Custom rebar.config:"/>
+        </properties>
+      </component>
+      <component id="13a8" class="com.intellij.ui.RawCommandLineEditor" binding="myCustomRebarConfigEditor">
+        <constraints>
+          <grid row="3" column="1" row-span="1" col-span="1" vsize-policy="3" hsize-policy="7" anchor="0" fill="1" indent="0" use-parent-layout="false"/>
+        </constraints>
+        <properties/>
+      </component>
+      <component id="81959" class="javax.swing.JLabel" binding="myCustomEunitRebarConfigLabel">
+        <constraints>
+          <grid row="4" column="0" row-span="1" col-span="1" vsize-policy="0" hsize-policy="0" anchor="8" fill="0" indent="0" use-parent-layout="false"/>
+        </constraints>
+        <properties>
+          <text value="Custom rebar.config for EUnit:"/>
+        </properties>
+      </component>
+      <component id="d43f1" class="com.intellij.ui.RawCommandLineEditor" binding="myCustomEunitRebarConfigEditor">
+        <constraints>
+          <grid row="4" column="1" row-span="1" col-span="1" vsize-policy="3" hsize-policy="7" anchor="0" fill="1" indent="0" use-parent-layout="false"/>
+        </constraints>
+        <properties/>
+      </component>
     </children>
   </grid>
 </form>

src/org/intellij/erlang/configuration/ErlangCompilerOptionsConfigurable.java

@@ -44,7 +44,11 @@ public class ErlangCompilerOptionsConfigurable extends CompilerConfigurable {
   private JCheckBox myAddDebugInfoCheckBox;
   private RawCommandLineEditor myAdditionalErlcArgumentsEditor;
   private JLabel myAdditionalErlcArgumentsLabel;
-  private final ErlangCompilerSettings mySettings;
+  private JLabel myCustomRebarConfigLabel;
+  private RawCommandLineEditor myCustomRebarConfigEditor;
+    private RawCommandLineEditor myCustomEunitRebarConfigEditor;
+    private JLabel myCustomEunitRebarConfigLabel;
+    private final ErlangCompilerSettings mySettings;
   private final Project myProject;
 
   public ErlangCompilerOptionsConfigurable(Project project) {
@@ -95,27 +99,37 @@ public void reset() {
     myConfigureRebarButton.setVisible(!rebarPathIsSet);
     setUseRebarCompiler(rebarPathIsSet && mySettings.isUseRebarCompilerEnabled());
     myAddDebugInfoCheckBox.setSelected(mySettings.isAddDebugInfoEnabled());
+    myCustomRebarConfigEditor.setText(mySettings.getCustomRebarConfig());
+    myCustomEunitRebarConfigEditor.setText(mySettings.getCustomEunitRebarConfig());
     myAdditionalErlcArgumentsEditor.setText(argumentsString(mySettings.getAdditionalErlcArguments()));
   }
 
   @Override
   public void apply() throws ConfigurationException {
     mySettings.setUseRebarCompilerEnabled(myUseRebarCompilerCheckBox.isSelected());
     mySettings.setAddDebugInfoEnabled(myAddDebugInfoCheckBox.isSelected());
+    mySettings.setCustomRebarConfig(myCustomRebarConfigEditor.getText());
+    mySettings.setCustomEunitRebarConfig(myCustomEunitRebarConfigEditor.getText());
     mySettings.setAdditionalErlcArguments(arguments(myAdditionalErlcArgumentsEditor.getText()));
   }
 
   @Override
   public boolean isModified() {
     return myUseRebarCompilerCheckBox.isSelected() != mySettings.isUseRebarCompilerEnabled() ||
            myAddDebugInfoCheckBox.isSelected() != mySettings.isAddDebugInfoEnabled() ||
+           !StringUtil.equals(myCustomRebarConfigEditor.getText(), mySettings.getCustomRebarConfig()) ||
+           !StringUtil.equals(myCustomEunitRebarConfigEditor.getText(), mySettings.getCustomEunitRebarConfig()) ||
            !StringUtil.equals(myAdditionalErlcArgumentsEditor.getText(),
                               argumentsString(mySettings.getAdditionalErlcArguments()));
   }
 
   private void setUseRebarCompiler(boolean useRebarCompiler) {
     myUseRebarCompilerCheckBox.setSelected(useRebarCompiler);
 
+    myCustomRebarConfigLabel.setVisible(useRebarCompiler);
+    myCustomRebarConfigEditor.setVisible(useRebarCompiler);
+    myCustomEunitRebarConfigLabel.setVisible(useRebarCompiler);
+    myCustomEunitRebarConfigEditor.setVisible(useRebarCompiler);
     myAdditionalErlcArgumentsLabel.setVisible(!useRebarCompiler);
     myAdditionalErlcArgumentsEditor.setVisible(!useRebarCompiler);
   }

src/org/intellij/erlang/configuration/ErlangCompilerSettings.java

@@ -55,6 +55,24 @@ public void setUseRebarCompilerEnabled(boolean useRebarCompiler) {
     myCompilerOptions.myUseRebarCompiler = useRebarCompiler;
   }
 
+  @NotNull
+  public String getCustomRebarConfig() {
+    return myCompilerOptions.myCustomRebarConfig;
+  }
+
+  public void setCustomRebarConfig(@NotNull String customRebarConfig) {
+    myCompilerOptions.myCustomRebarConfig = customRebarConfig;
+  }
+
+  @NotNull
+  public String getCustomEunitRebarConfig() {
+    return myCompilerOptions.myCustomEunitRebarConfig;
+  }
+
+  public void setCustomEunitRebarConfig(@NotNull String customEunitRebarConfig) {
+    myCompilerOptions.myCustomEunitRebarConfig = customEunitRebarConfig;
+  }
+
   public boolean isAddDebugInfoEnabled() {
     return myCompilerOptions.myAddDebugInfoEnabled;
   }

src/org/intellij/erlang/console/ErlangConsoleCommandLineState.java

@@ -58,7 +58,7 @@ protected ProcessHandler startProcess() throws ExecutionException {
     commandLine.setExePath(ErlangConsoleUtil.getErlPath(project, module));
     String consoleArgs = myConfig.getConsoleArgs();
     commandLine.addParameters(StringUtil.split(consoleArgs, " "));
-    commandLine.addParameters(ErlangConsoleUtil.getCodePath(project, module, false));
+    commandLine.addParameters(ErlangConsoleUtil.getCodePath(project, module, false, false));
     commandLine.setWorkDirectory(ErlangConsoleUtil.getWorkingDirPath(project, myConfig.getWorkingDirPath()));
     OSProcessHandler handler = new OSProcessHandler(commandLine.createProcess(), commandLine.getCommandLineString());
     ProcessTerminatedListener.attach(handler);

src/org/intellij/erlang/console/ErlangConsoleUtil.java

@@ -47,12 +47,13 @@ public static void attachFilters(@NotNull Project project, @NotNull ConsoleView
   }
 
   @NotNull
-  public static List<String> getCodePath(@NotNull Module module, boolean forTests) {
-    return getCodePath(module.getProject(), module, forTests);
+  public static List<String> getCodePath(@NotNull Module module, boolean forTests, boolean useRebarPaths) {
+    return getCodePath(module.getProject(), module, forTests, useRebarPaths);
   }
 
   @NotNull
-  public static List<String> getCodePath(@NotNull Project project, @Nullable Module module, boolean useTestOutputPath) {
+  public static List<String> getCodePath(@NotNull Project project, @Nullable Module module, boolean useTestOutputPath,
+                                         boolean useRebarPaths) {
     final Set<Module> codePathModules = new HashSet<>();
     if (module != null) {
       ModuleRootManager moduleRootMgr = ModuleRootManager.getInstance(module);
@@ -66,20 +67,35 @@ public static List<String> getCodePath(@NotNull Project project, @Nullable Modul
     }
 
     List<String> codePath = new ArrayList<>(codePathModules.size() * 2);
-    for (Module codePathModule : codePathModules) {
-      ModuleRootManager moduleRootManager = ModuleRootManager.getInstance(codePathModule);
-      CompilerModuleExtension compilerModuleExt =
-        moduleRootManager.getModuleExtension(CompilerModuleExtension.class);
-      VirtualFile buildOutput = useTestOutputPath && codePathModule == module ?
-        getCompilerOutputPathForTests(compilerModuleExt) : 
-        compilerModuleExt.getCompilerOutputPath();
-      if (buildOutput != null) {
+
+    if (module != null) {
+      for (VirtualFile contentRoot : ModuleRootManager.getInstance(module).getContentRoots()) {
         codePath.add("-pa");
-        codePath.add(buildOutput.getCanonicalPath());
+        codePath.add(new File(contentRoot.getPath(), ".eunit").toString());
       }
-      for (VirtualFile contentRoot : ModuleRootManager.getInstance(codePathModule).getContentRoots()) {
-        codePath.add("-pa");
-        codePath.add(contentRoot.getPath());
+    }
+
+    for (Module codePathModule : codePathModules) {
+      if (useRebarPaths) {
+        for (VirtualFile contentRoot : ModuleRootManager.getInstance(codePathModule).getContentRoots()) {
+          codePath.add("-pa");
+          codePath.add(new File(contentRoot.getPath(), "ebin").toString());
+        }
+      } else {
+        ModuleRootManager moduleRootManager = ModuleRootManager.getInstance(codePathModule);
+        CompilerModuleExtension compilerModuleExt =
+          moduleRootManager.getModuleExtension(CompilerModuleExtension.class);
+        VirtualFile buildOutput = useTestOutputPath && codePathModule == module ?
+          getCompilerOutputPathForTests(compilerModuleExt) :
+          compilerModuleExt.getCompilerOutputPath();
+        if (buildOutput != null) {
+          codePath.add("-pa");
+          codePath.add(buildOutput.getCanonicalPath());
+        }
+        for (VirtualFile contentRoot : ModuleRootManager.getInstance(codePathModule).getContentRoots()) {
+          codePath.add("-pa");
+          codePath.add(contentRoot.getPath());
+        }
       }
     }
 

src/org/intellij/erlang/debugger/remote/ErlangRemoteDebugRunConfiguration.java

@@ -43,6 +43,11 @@ public boolean isUseTestCodePath() {
     return false;
   }
 
+  @Override
+  public boolean isUseRebarPaths() {
+    return false;
+  }
+
   @Override
   protected ErlangRemoteDebugRunningState newRunningState(ExecutionEnvironment env, Module module) {
     return new ErlangRemoteDebugRunningState(env, module, this);

src/org/intellij/erlang/debugger/remote/ErlangRemoteDebugRunningState.java

@@ -47,6 +47,11 @@ protected boolean useTestCodePath() {
     return false;
   }
 
+  @Override
+  protected boolean useRebarOutputPaths() {
+    return false;
+  }
+
   @Override
   protected boolean isNoShellMode() {
     return true;