K2JSBrowserProgramRunner copies output JavaScript file from output dir instead of generating JavaScript againg

idea/src/org/jetbrains/jet/plugin/k2jsrun/K2JSBrowserProgramRunner.java

@@ -23,58 +23,35 @@ import com.intellij.execution.configurations.RunProfileState;
 import com.intellij.execution.runners.ExecutionEnvironment;
 import com.intellij.execution.runners.GenericProgramRunner;
 import com.intellij.execution.ui.RunContentDescriptor;
-import com.intellij.ide.browsers.BrowsersConfiguration;
 import com.intellij.openapi.project.Project;
-import com.intellij.openapi.vfs.LocalFileSystem;
-import com.intellij.openapi.vfs.VirtualFileManager;
 import org.jetbrains.annotations.NotNull;
 
+import static org.jetbrains.jet.plugin.k2jsrun.K2JSRunnerUtils.copyJSFileFromOutputToDestination;
+import static org.jetbrains.jet.plugin.k2jsrun.K2JSRunnerUtils.openBrowser;
+
 /**
  * @author Pavel Talanov
  */
 public final class K2JSBrowserProgramRunner extends GenericProgramRunner {
     @Override
-    protected RunContentDescriptor doExecute(Project project,
+    protected RunContentDescriptor doExecute(final Project project,
-                                             Executor executor,
+            Executor executor,
-                                             RunProfileState state,
+            RunProfileState state,
-                                             RunContentDescriptor contentToReuse,
+            RunContentDescriptor contentToReuse,
-                                             ExecutionEnvironment env) throws ExecutionException {
+            ExecutionEnvironment env) throws ExecutionException {
         if (project == null) {
             return null;
         }
         try {
-            K2JSConfigurationSettings configurationSettings = getSettings(state);
+            copyJSFileFromOutputToDestination(project, K2JSRunnerUtils.getSettings(state));
-            try {
+            openBrowser(K2JSRunnerUtils.getSettings(state));
-                K2JSRunnerUtils.translateAndSave(project, configurationSettings.getGeneratedFilePath());
-            }
-            catch (Throwable e) {
-                K2JSRunnerUtils.notifyFailure(e);
-                return null;
-            }
-            openBrowser(configurationSettings);
         }
-        catch (Exception e) {
+        catch (Throwable e) {
             throw new ExecutionException(e);
         }
         return null;
     }
 
-    private static void openBrowser(@NotNull K2JSConfigurationSettings configurationSettings) {
-        if (!configurationSettings.isShouldOpenInBrowserAfterTranslation()) {
-            return;
-        }
-        String filePath = configurationSettings.getPageToOpenFilePath();
-        String url = VirtualFileManager.constructUrl(LocalFileSystem.PROTOCOL, filePath);
-        BrowsersConfiguration.launchBrowser(configurationSettings.getBrowserFamily(), url);
-    }
-
-    @NotNull
-    private static K2JSConfigurationSettings getSettings(@NotNull RunProfileState state) {
-        RunProfile profile = state.getRunnerSettings().getRunProfile();
-        assert profile instanceof K2JSRunConfiguration;
-        return ((K2JSRunConfiguration)profile).settings();
-    }
-
     @NotNull
     @Override
     public String getRunnerId() {

idea/src/org/jetbrains/jet/plugin/k2jsrun/K2JSRunnerUtils.java

@@ -16,28 +16,22 @@
 
 package org.jetbrains.jet.plugin.k2jsrun;
 
-import com.google.common.collect.Lists;
+import com.intellij.execution.configurations.RunProfile;
-import com.google.common.collect.Sets;
+import com.intellij.execution.configurations.RunProfileState;
-import com.intellij.notification.Notification;
+import com.intellij.ide.browsers.BrowsersConfiguration;
-import com.intellij.notification.NotificationType;
+import com.intellij.openapi.compiler.CompilerPaths;
-import com.intellij.notification.Notifications;
 import com.intellij.openapi.module.Module;
 import com.intellij.openapi.module.ModuleManager;
 import com.intellij.openapi.project.Project;
-import com.intellij.openapi.roots.ModuleRootManager;
+import com.intellij.openapi.util.io.FileUtil;
+import com.intellij.openapi.vfs.LocalFileSystem;
 import com.intellij.openapi.vfs.VirtualFile;
-import com.intellij.psi.PsiFile;
+import com.intellij.openapi.vfs.VirtualFileManager;
-import com.intellij.psi.PsiManager;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.jet.lang.psi.JetFile;
+import org.jetbrains.annotations.Nullable;
-import org.jetbrains.jet.plugin.project.IDEAConfig;
-import org.jetbrains.k2js.facade.K2JSTranslator;
 
-import java.util.Collection;
+import java.io.File;
-import java.util.List;
+import java.io.IOException;
-import java.util.Set;
-
-import static org.jetbrains.jet.plugin.actions.JavaToKotlinActionUtil.allVirtualFiles;
 
 /**
  * @author Pavel Talanov
@@ -47,57 +41,57 @@ public final class K2JSRunnerUtils {
     private K2JSRunnerUtils() {
     }
 
-    public static void notifyFailure(@NotNull Throwable exception) {
-        Notifications.Bus.notify(new Notification("JsTranslator", "Translation failed.",
-                                                  "Exception: " + exception.getMessage(),
-                                                  NotificationType.ERROR));
-    }
-
-    private static void notifySuccess(@NotNull String outputPath) {
-        Notifications.Bus.notify(new Notification("JsTranslator", "Translation successful.",
-                                                  "Generated file: " + outputPath,
-                                                  NotificationType.INFORMATION));
-    }
-
-    public static void translateAndSave(@NotNull Project project, @NotNull String outputDirPath) throws Exception {
-        Set<VirtualFile> allVirtualFiles = getAllProjectVirtualFiles(project);
-        List<JetFile> kotlinFiles = getJetFiles(allVirtualFiles, project);
-        String outputFilePath = constructPathToGeneratedFile(project, outputDirPath);
-        K2JSTranslator.translateWithCallToMainAndSaveToFile(kotlinFiles,
-                                                            outputFilePath,
-                                                            new IDEAConfig(project)
-        );
-        notifySuccess(outputDirPath);
-    }
-
     @NotNull
     public static String constructPathToGeneratedFile(@NotNull Project project, @NotNull String outputDirPath) {
         return outputDirPath + "/" + project.getName() + ".js";
     }
 
-    @NotNull
+    public static void copyJSFileFromOutputToDestination(@NotNull Project project,
-    private static Set<VirtualFile> getAllProjectVirtualFiles(@NotNull Project project) {
+            @NotNull K2JSConfigurationSettings configurationSettings) {
-        Module[] modules = ModuleManager.getInstance(project).getModules();
+        VirtualFile outputDir = getOutputDir(project);
-        Set<VirtualFile> allVirtualFiles = Sets.newHashSet();
+        if (outputDir == null) {
-        for (Module module : modules) {
+            throw new RuntimeException("Cannot find output dir for project " + project.getName());
-            VirtualFile[] roots = ModuleRootManager.getInstance(module).getSourceRoots();
-            allVirtualFiles.addAll(allVirtualFiles(roots));
         }
-        return allVirtualFiles;
+        String pathToGeneratedJsFile = constructPathToGeneratedFile(project, outputDir.getPath());
+        try {
+            File fileToCopy = new File(pathToGeneratedJsFile);
+            File dirToCopyTo = new File(configurationSettings.getGeneratedFilePath());
+            File fileToCopyTo = new File(dirToCopyTo, fileToCopy.getName());
+            FileUtil.copy(fileToCopy, fileToCopyTo);
+        }
+        catch (IOException e) {
+            throw new RuntimeException("Output JavaScript file was not generated or missing.", e);
+        }
+    }
+
+    @Nullable
+    private static VirtualFile getOutputDir(@NotNull Project project) {
+        Module module = getJsModule(project);
+        return CompilerPaths.getModuleOutputDirectory(module, /*forTests = */ false);
     }
 
     @NotNull
-    private static List<JetFile> getJetFiles(@NotNull Collection<VirtualFile> virtualFiles,
+    private static Module getJsModule(@NotNull Project project) {
-            @NotNull Project project) {
+        Module[] modules = ModuleManager.getInstance(project).getModules();
-        List<JetFile> kotlinFiles = Lists.newArrayList();
+        if (modules.length != 1) {
-
+            throw new UnsupportedOperationException("Kotlin to JavaScript translator temporarily does not support multiple modules.");
-        PsiManager psiManager = PsiManager.getInstance(project);
-        for (VirtualFile virtualFile : virtualFiles) {
-            PsiFile psiFile = psiManager.findFile(virtualFile);
-            if (psiFile instanceof JetFile) {
-                kotlinFiles.add((JetFile) psiFile);
-            }
         }
-        return kotlinFiles;
+        return modules[0];
+    }
+
+    public static void openBrowser(@NotNull K2JSConfigurationSettings configurationSettings) {
+        if (!configurationSettings.isShouldOpenInBrowserAfterTranslation()) {
+            return;
+        }
+        String filePath = configurationSettings.getPageToOpenFilePath();
+        String url = VirtualFileManager.constructUrl(LocalFileSystem.PROTOCOL, filePath);
+        BrowsersConfiguration.launchBrowser(configurationSettings.getBrowserFamily(), url);
+    }
+
+    @NotNull
+    public static K2JSConfigurationSettings getSettings(@NotNull RunProfileState state) {
+        RunProfile profile = state.getRunnerSettings().getRunProfile();
+        assert profile instanceof K2JSRunConfiguration;
+        return ((K2JSRunConfiguration) profile).settings();
     }
 }