run configuration producer

idea/src/META-INF/plugin.xml

@@ -34,6 +34,7 @@
       <annotator language="jet" implementationClass="org.jetbrains.jet.plugin.annotations.JetPsiChecker"/>
       <documentationProvider implementation="org.jetbrains.jet.plugin.JetQuickDocumentationProvider"/>
       <configurationType implementation="org.jetbrains.jet.plugin.run.JetRunConfigurationType"/>
+      <configurationProducer implementation="org.jetbrains.jet.plugin.run.JetRunConfigurationProducer"/>
       <codeInsight.lineMarkerProvider language="jet" implementationClass="org.jetbrains.jet.plugin.annotations.JetLineMarkerProvider"/>
       <iconProvider implementation="org.jetbrains.jet.plugin.JetIconProvider"/>
       <fileTypeIndentOptionsProvider implementation="org.jetbrains.jet.plugin.formatter.JetIndentOptionsProvider"/>

idea/src/org/jetbrains/jet/lang/psi/JetClass.java

@@ -1,6 +1,7 @@
 package org.jetbrains.jet.lang.psi;
 
 import com.intellij.lang.ASTNode;
+import com.intellij.psi.util.PsiTreeUtil;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.JetNodeTypes;
@@ -90,4 +91,15 @@ public class JetClass extends JetTypeParameterListOwner implements JetClassOrObj
 
         return body.getProperties();
     }
+
+    public String getFQName() {
+        JetNamedDeclaration parent = PsiTreeUtil.getParentOfType(this, JetNamespace.class, JetClass.class);
+        if (parent instanceof JetNamespace) {
+            return ((JetNamespace) parent).getFQName() + "." + getName();
+        }
+        if (parent instanceof JetClass) {
+            return ((JetClass) parent).getFQName() + "." + getName();
+        }
+        return getName();
+    }
 }

idea/src/org/jetbrains/jet/plugin/run/JetRunConfigurationProducer.java

@@ -0,0 +1,80 @@
+package org.jetbrains.jet.plugin.run;
+
+import com.intellij.execution.Location;
+import com.intellij.execution.RunnerAndConfigurationSettings;
+import com.intellij.execution.actions.ConfigurationContext;
+import com.intellij.execution.junit.RuntimeConfigurationProducer;
+import com.intellij.openapi.module.Module;
+import com.intellij.openapi.util.text.StringUtil;
+import com.intellij.psi.PsiElement;
+import com.intellij.psi.PsiFile;
+import org.jetbrains.jet.lang.psi.*;
+
+import java.util.List;
+
+/**
+ * @author yole
+ */
+public class JetRunConfigurationProducer extends RuntimeConfigurationProducer implements Cloneable {
+    private PsiElement mySourceElement;
+
+    public JetRunConfigurationProducer() {
+        super(JetRunConfigurationType.getInstance());
+    }
+
+    @Override
+    public PsiElement getSourceElement() {
+        return mySourceElement;
+    }
+
+    @Override
+    protected RunnerAndConfigurationSettings createConfigurationByElement(Location location, ConfigurationContext configurationContext) {
+        JetClass containingClass = (JetClass) location.getParentElement(JetClass.class);
+        if (containingClass != null && hasMain(containingClass.getDeclarations())) {
+            mySourceElement = containingClass;
+            return createConfigurationByQName(location.getModule(), configurationContext, containingClass.getFQName());
+        }
+        PsiFile psiFile = location.getPsiElement().getContainingFile();
+        if (psiFile instanceof JetFile) {
+            JetNamespace namespace = ((JetFile) psiFile).getRootNamespace();
+            if (hasMain(namespace.getDeclarations())) {
+                mySourceElement = namespace;
+                return createConfigurationByQName(location.getModule(), configurationContext, namespace.getFQName() + ".namespace");
+            }
+        }
+        return null;
+    }
+
+    private boolean hasMain(List<JetDeclaration> declarations) {
+        for (JetDeclaration declaration : declarations) {
+            if (declaration instanceof JetFunction) {
+                JetFunction function = (JetFunction) declaration;
+                if ("main".equals(function.getName())) {
+                    List<JetParameter> parameters = function.getValueParameters();
+                    if (parameters.size() == 1) {
+                        JetTypeReference reference = parameters.get(0).getTypeReference();
+                        if (reference != null && reference.getText().equals("Array<String>")) {  // TODO correct check
+                            return true;
+                        }
+                    }
+                }
+
+            }
+        }
+        return false;
+    }
+
+    private RunnerAndConfigurationSettings createConfigurationByQName(Module module, ConfigurationContext context, String fqName) {
+        RunnerAndConfigurationSettings settings = cloneTemplateConfiguration(module.getProject(), context);
+        JetRunConfiguration configuration = (JetRunConfiguration) settings.getConfiguration();
+        configuration.setModule(module);
+        configuration.setName(StringUtil.trimEnd(fqName, ".namespace"));
+        configuration.MAIN_CLASS_NAME = fqName;
+        return settings;
+    }
+
+    @Override
+    public int compareTo(Object o) {
+        return PREFERED;
+    }
+}

idea/src/org/jetbrains/jet/plugin/run/JetRunConfigurationType.java

@@ -9,6 +9,10 @@ import org.jetbrains.jet.plugin.JetFileType;
  * @author yole
  */
 public class JetRunConfigurationType extends ConfigurationTypeBase {
+    public static JetRunConfigurationType getInstance() {
+        return ConfigurationTypeUtil.findConfigurationType(JetRunConfigurationType.class);
+    }
+
     public JetRunConfigurationType() {
         super("JetRunConfigurationType", "Jet", "Jet", JetFileType.INSTANCE.getIcon());
         addFactory(new JetRunConfigurationFactory(this));