Initial support of python debug console.
authorDmitry Trofimov <dmitry.trofimov@jetbrains.com>
Fri, 29 Oct 2010 12:41:19 +0000 (16:41 +0400)
committerDmitry Trofimov <dmitry.trofimov@jetbrains.com>
Fri, 29 Oct 2010 12:41:19 +0000 (16:41 +0400)
+some refactorings

14 files changed:
java/java-impl/src/com/intellij/psi/impl/source/codeStyle/JavaHelperFactory.java
java/java-impl/src/com/intellij/psi/impl/source/codeStyle/JavaIndentHelper.java [moved from java/java-impl/src/com/intellij/psi/impl/source/codeStyle/JavaHelper.java with 94% similarity]
java/java-impl/src/com/intellij/psi/impl/source/codeStyle/ShiftIndentInsideHelper.java
platform/lang-impl/src/com/intellij/execution/runners/AbstractConsoleRunnerWithHistory.java
platform/lang-impl/src/com/intellij/execution/runners/ConsoleExecuteActionHandler.java [new file with mode: 0644]
platform/lang-impl/src/com/intellij/facet/impl/ui/MultipleFacetEditorHelperImpl.java
platform/lang-impl/src/com/intellij/psi/impl/source/PostprocessReformattingAspect.java
platform/lang-impl/src/com/intellij/psi/impl/source/codeStyle/CodeEditUtil.java
platform/lang-impl/src/com/intellij/psi/impl/source/codeStyle/CodeStyleManagerImpl.java
platform/lang-impl/src/com/intellij/psi/impl/source/codeStyle/HelperFactory.java
platform/lang-impl/src/com/intellij/psi/impl/source/codeStyle/IndentHelper.java [moved from platform/lang-impl/src/com/intellij/psi/impl/source/codeStyle/Helper.java with 96% similarity]
platform/platform-api/src/com/intellij/execution/process/CommandLineArgumentsProvider.java
plugins/InspectionGadgets/src/com/siyeh/ig/inheritance/AbstractMethodWithMissingImplementationsInspection.java
xml/impl/src/com/intellij/lang/html/HtmlParsing.java

index 0a372306d6c1acc249debcad8326bf13d59de06c..f54d43485d93365a347ac043cb4258dd102ea9c4 100644 (file)
@@ -23,7 +23,7 @@ import com.intellij.openapi.fileTypes.FileType;
 import com.intellij.openapi.project.Project;
 
 public class JavaHelperFactory implements HelperFactory.Factory {
-  public Helper create(final FileType fileType, final Project project) {
-    return new JavaHelper(fileType, project);
+  public IndentHelper create(final FileType fileType, final Project project) {
+    return new JavaIndentHelper(fileType, project);
   }
 }
\ No newline at end of file
similarity index 94%
rename from java/java-impl/src/com/intellij/psi/impl/source/codeStyle/JavaHelper.java
rename to java/java-impl/src/com/intellij/psi/impl/source/codeStyle/JavaIndentHelper.java
index 01e8b038951961934f69099bf51d59d13d885519..5fd7811feb60475143127e612d857580ca73eace 100644 (file)
@@ -26,13 +26,13 @@ import com.intellij.psi.impl.source.tree.CompositeElement;
 import com.intellij.psi.impl.source.tree.ElementType;
 import com.intellij.psi.impl.source.tree.TreeUtil;
 
-public class JavaHelper extends Helper {
-  public JavaHelper(final FileType fileType, final Project project) {
+public class JavaIndentHelper extends IndentHelper {
+  public JavaIndentHelper(final FileType fileType, final Project project) {
     super(fileType, project);
   }
 
   protected int getIndentInner(final ASTNode element, final boolean includeNonSpace, final int recursionLevel) {
-    if (recursionLevel > TOO_BIG_WALK_THRESHOULD) return 0;
+    if (recursionLevel > TOO_BIG_WALK_THRESHOLD) return 0;
 
     if (element.getTreePrev() != null) {
       ASTNode prev = element.getTreePrev();
index d828085352a9687c16a0bb16b17de2ec128c304b..6b9ff5fd85eb157eff8c2dd89f261fd6fd76892c 100644 (file)
@@ -43,12 +43,12 @@ public class ShiftIndentInsideHelper {
 
   private final CodeStyleSettings mySettings;
   private final FileType myFileType;
-  private final Helper myIndentHelper;
+  private final IndentHelper myIndentIndentHelper;
 
   public ShiftIndentInsideHelper(FileType fileType, Project project) {
     mySettings = CodeStyleSettingsManager.getSettings(project);
     myFileType = fileType;
-    myIndentHelper = HelperFactory.createHelper(fileType, project);
+    myIndentIndentHelper = HelperFactory.createHelper(fileType, project);
   }
 
   private static int getStartOffset(ASTNode root, ASTNode child) {
@@ -75,10 +75,10 @@ public class ShiftIndentInsideHelper {
         }
                     if (c == '\n' || c == '\r') continue;
         String space = text.substring(offset + 1, offset1);
-        int indent = myIndentHelper.getIndent(space, true);
+        int indent = myIndentIndentHelper.getIndent(space, true);
         int newIndent = indent + indentShift;
         newIndent = Math.max(newIndent, 0);
-        String newSpace = myIndentHelper.fillIndent(newIndent);
+        String newSpace = myIndentIndentHelper.fillIndent(newIndent);
 
         ASTNode leaf = element.findLeafElementAt(offset);
         if (!mayShiftIndentInside(leaf)) {
@@ -96,7 +96,7 @@ public class ShiftIndentInsideHelper {
           ) &&
               next != element) {
             if (mySettings.KEEP_FIRST_COLUMN_COMMENT) {
-              int commentIndent = myIndentHelper.getIndent(next, true);
+              int commentIndent = myIndentIndentHelper.getIndent(next, true);
               if (commentIndent == 0) continue;
             }
           }
index 53c8e402ef93b973244c6afff6027d9ac68d962b..ae4dc897502ad25cdb5f035caef613e4150a7b72 100644 (file)
@@ -15,6 +15,7 @@
  */
 package com.intellij.execution.runners;
 
+import com.google.common.collect.Lists;
 import com.intellij.codeInsight.lookup.Lookup;
 import com.intellij.codeInsight.lookup.LookupManager;
 import com.intellij.execution.ExecutionException;
@@ -32,13 +33,10 @@ import com.intellij.openapi.actionSystem.*;
 import com.intellij.openapi.application.ApplicationManager;
 import com.intellij.openapi.application.Result;
 import com.intellij.openapi.command.WriteCommandAction;
-import com.intellij.openapi.editor.Document;
 import com.intellij.openapi.editor.ex.EditorEx;
 import com.intellij.openapi.project.DumbAwareAction;
 import com.intellij.openapi.project.Project;
 import com.intellij.openapi.util.IconLoader;
-import com.intellij.openapi.util.TextRange;
-import com.intellij.openapi.util.text.StringUtil;
 import com.intellij.openapi.wm.IdeFocusManager;
 import com.intellij.openapi.wm.ToolWindow;
 import com.intellij.openapi.wm.ToolWindowManager;
@@ -48,27 +46,27 @@ import org.jetbrains.annotations.Nullable;
 
 import javax.swing.*;
 import java.awt.*;
-import java.io.IOException;
-import java.io.OutputStream;
-import java.nio.charset.Charset;
+import java.util.List;
 
 /**
  * @author oleg
- * This class provides basic functionality for running consoles.
- * It launches extrnal process and handles line input with history
+ *         This class provides basic functionality for running consoles.
+ *         It launches extrnal process and handles line input with history
  */
 public abstract class AbstractConsoleRunnerWithHistory {
-  protected final Project myProject;
-  protected final String myConsoleTitle;
+  private final Project myProject;
+  private final String myConsoleTitle;
 
-  protected OSProcessHandler myProcessHandler;
-  protected final CommandLineArgumentsProvider myProvider;
-  protected final String myWorkingDir;
+  private ProcessHandler myProcessHandler;
+  private final CommandLineArgumentsProvider myProvider;
+  private final String myWorkingDir;
+
+  private LanguageConsoleViewImpl myConsoleView;
 
-  protected LanguageConsoleViewImpl myConsoleView;
-  private final ConsoleHistoryModel myHistory = new ConsoleHistoryModel();
   private AnAction myRunAction;
 
+  private ConsoleExecuteActionHandler myConsoleExecuteActionHandler;
+
   public AbstractConsoleRunnerWithHistory(@NotNull final Project project,
                                           @NotNull final String consoleTitle,
                                           @NotNull final CommandLineArgumentsProvider provider,
@@ -81,16 +79,19 @@ public abstract class AbstractConsoleRunnerWithHistory {
 
   /**
    * Launch process, setup history, actions etc.
+   *
    * @throws ExecutionException
    */
   public void initAndRun() throws ExecutionException {
     // Create Server process
-    final Process process = createProcess();
+    final Process process = createProcess(myProvider);
 
     // Init console view
     myConsoleView = createConsoleView();
 
-    myProcessHandler = createProcessHandler(process);
+    myProcessHandler = createProcessHandler(process, myProvider.getCommandLineString());
+
+    myConsoleExecuteActionHandler = createConsoleExecuteActionHandler();
 
     ProcessTerminatedListener.attach(myProcessHandler);
 
@@ -147,11 +148,11 @@ public abstract class AbstractConsoleRunnerWithHistory {
   protected abstract LanguageConsoleViewImpl createConsoleView();
 
   @Nullable
-  protected abstract Process createProcess() throws ExecutionException;
+  protected abstract Process createProcess(CommandLineArgumentsProvider provider) throws ExecutionException;
 
-  protected abstract OSProcessHandler createProcessHandler(final Process process);
+  protected abstract OSProcessHandler createProcessHandler(final Process process, final String commandLine);
 
-  private void registerActionShortcuts(final AnAction[] actions, final JComponent component) {
+  public static void registerActionShortcuts(final AnAction[] actions, final JComponent component) {
     for (AnAction action : actions) {
       if (action.getShortcutSet() != null) {
         action.registerCustomShortcutSet(action.getShortcutSet(), component);
@@ -162,106 +163,159 @@ public abstract class AbstractConsoleRunnerWithHistory {
   protected AnAction[] fillToolBarActions(final DefaultActionGroup toolbarActions,
                                           final Executor defaultExecutor,
                                           final RunContentDescriptor myDescriptor) {
+
+    List<AnAction> actionList = Lists.newArrayList();
+
 //stop
     final AnAction stopAction = createStopAction();
-    toolbarActions.add(stopAction);
+    actionList.add(stopAction);
 
 //close
     final AnAction closeAction = createCloseAction(defaultExecutor, myDescriptor);
-    toolbarActions.add(closeAction);
+    actionList.add(closeAction);
 
-// run action
-    myRunAction = new DumbAwareAction(null, null, IconLoader.getIcon("/actions/execute.png")) {
-      public void actionPerformed(final AnActionEvent e) {
-        runExecuteActionInner();
-      }
+// run and history actions
 
-      public void update(final AnActionEvent e) {
-        final EditorEx editor = getLanguageConsole().getConsoleEditor();
-        final Lookup lookup = LookupManager.getActiveLookup(editor);
-        e.getPresentation().setEnabled(!myProcessHandler.isProcessTerminated() &&
-                                       (lookup == null || !lookup.isCompletion()));
-      }
-    };
-    EmptyAction.setupAction(myRunAction, "Console.Execute", null);
-    toolbarActions.add(myRunAction);
+    ConsoleExecutionActions executionActions =
+      createConsoleExecActions(getLanguageConsole(), myProcessHandler, myConsoleExecuteActionHandler);
+    myRunAction = executionActions.getRunAction();
+    actionList.addAll(executionActions.getActionsAsList());
 
 // Help
-    toolbarActions.add(CommonActionsManager.getInstance().createHelpAction("interactive_console"));
+    actionList.add(CommonActionsManager.getInstance().createHelpAction("interactive_console"));
+
+    AnAction[] actions = actionList.toArray(new AnAction[actionList.size()]);
+
+    toolbarActions.addAll(actions);
+
+    return actions;
+  }
+
+  protected AnAction createCloseAction(final Executor defaultExecutor, final RunContentDescriptor myDescriptor) {
+    return new CloseAction(defaultExecutor, myDescriptor, myProject);
+  }
+
+  protected AnAction createStopAction() {
+    return ActionManager.getInstance().getAction(IdeActions.ACTION_STOP_PROGRAM);
+  }
+
+  public LanguageConsoleImpl getLanguageConsole() {
+    return myConsoleView.getConsole();
+  }
+
+  public static ConsoleExecutionActions createConsoleExecActions(final LanguageConsoleImpl languageConsole,
+                                                                 final ProcessHandler processHandler,
+                                                                 final ConsoleExecuteActionHandler consoleExecuteActionHandler) {
+    final ConsoleHistoryModel myHistory = new ConsoleHistoryModel();
+
+    final AnAction runAction = new ConsoleExecuteAction(languageConsole,
+                                                        myHistory, processHandler, consoleExecuteActionHandler);
 
-// history actions
     final PairProcessor<AnActionEvent, String> historyProcessor = new PairProcessor<AnActionEvent, String>() {
       public boolean process(final AnActionEvent e, final String s) {
-        new WriteCommandAction(myProject, getLanguageConsole().getFile()) {
+        new WriteCommandAction(languageConsole.getProject(), languageConsole.getFile()) {
           protected void run(final Result result) throws Throwable {
-            getLanguageConsole().getEditorDocument().setText(s == null? "" : s);
+            languageConsole.getEditorDocument().setText(s == null ? "" : s);
           }
         }.execute();
         return true;
       }
     };
+
     final AnAction historyNextAction = ConsoleHistoryModel.createHistoryAction(myHistory, true, historyProcessor);
     final AnAction historyPrevAction = ConsoleHistoryModel.createHistoryAction(myHistory, false, historyProcessor);
     historyNextAction.getTemplatePresentation().setVisible(false);
     historyPrevAction.getTemplatePresentation().setVisible(false);
-    toolbarActions.add(historyNextAction);
-    toolbarActions.add(historyPrevAction);
 
-    return new AnAction[]{stopAction, closeAction, myRunAction, historyNextAction, historyPrevAction};
+    return new ConsoleExecutionActions(runAction, historyNextAction, historyPrevAction);
   }
 
-  protected AnAction createCloseAction(final Executor defaultExecutor, final RunContentDescriptor myDescriptor) {
-    return new CloseAction(defaultExecutor, myDescriptor, myProject);
-  }
+  @NotNull
+  protected abstract ConsoleExecuteActionHandler createConsoleExecuteActionHandler();
 
-  protected AnAction createStopAction() {
-    return ActionManager.getInstance().getAction(IdeActions.ACTION_STOP_PROGRAM);
-  }
+  public static class ConsoleExecutionActions {
+    private final AnAction myRunAction;
+    private final AnAction myNextAction;
+    private final AnAction myPrevAction;
 
-  public void processLine(final String line) {
-    final Charset charset = myProcessHandler.getCharset();
-    final OutputStream outputStream = myProcessHandler.getProcessInput();
-    try {
-      byte[] bytes = (line + "\n").getBytes(charset.name());
-      outputStream.write(bytes);
-      outputStream.flush();
+
+    public ConsoleExecutionActions(AnAction runAction, AnAction nextAction, AnAction prevAction) {
+      myRunAction = runAction;
+      myNextAction = nextAction;
+      myPrevAction = prevAction;
     }
-    catch (IOException e) {
-      // ignore
+
+    public AnAction[] getActions() {
+      return getActionsAsList().toArray(new AnAction[getActionsAsList().size()]);
     }
-  }
 
-  public LanguageConsoleImpl getLanguageConsole() {
-    return myConsoleView.getConsole();
-  }
 
-  protected void runExecuteActionInner() {
-    // Process input and add to history
-    final Document document = getLanguageConsole().getCurrentEditor().getDocument();
-    final String text = document.getText();
-    final TextRange range = new TextRange(0, document.getTextLength());
-    getLanguageConsole().getCurrentEditor().getSelectionModel().setSelection(range.getStartOffset(), range.getEndOffset());
-    getLanguageConsole().addCurrentToHistory(range, false);
-    getLanguageConsole().setInputText("");
-    if (!StringUtil.isEmptyOrSpaces(text)){
-      myHistory.addToHistory(text);
+    public List<AnAction> getActionsAsList() {
+      return Lists.newArrayList(myRunAction, myNextAction, myPrevAction);
+    }
+
+    public AnAction getRunAction() {
+      return myRunAction;
     }
-    // Send to interpreter / server
-    processLine(text);
   }
 
-  protected static String getProviderCommandLine(final CommandLineArgumentsProvider provider) {
-    final StringBuilder builder = new StringBuilder();
-    for (String s : provider.getArguments()) {
-      if (builder.length() > 0){
-        builder.append(' ');
-      }
-      builder.append(s);
+
+  public static class ConsoleExecuteAction extends DumbAwareAction {
+    public static final String ACTIONS_EXECUTE_ICON = "/actions/execute.png";
+    public static final String CONSOLE_EXECUTE = "Console.Execute";
+
+    private final LanguageConsoleImpl myLanguageConsole;
+    private final ConsoleHistoryModel myHistory;
+    private final ProcessHandler myProcessHandler;
+
+    private final ConsoleExecuteActionHandler myConsoleExecuteActionHandler;
+
+
+    public ConsoleExecuteAction(LanguageConsoleImpl languageConsole,
+                                ConsoleHistoryModel history,
+                                ProcessHandler processHandler,
+                                ConsoleExecuteActionHandler consoleExecuteActionHandler) {
+      super(null, null, IconLoader.getIcon(ACTIONS_EXECUTE_ICON));
+      myLanguageConsole = languageConsole;
+      myHistory = history;
+      myProcessHandler = processHandler;
+      myConsoleExecuteActionHandler = consoleExecuteActionHandler;
+      EmptyAction.setupAction(this, CONSOLE_EXECUTE, null);
+    }
+
+    public void actionPerformed(final AnActionEvent e) {
+      myConsoleExecuteActionHandler.runExecuteAction(myLanguageConsole, myHistory);
+    }
+
+    public void update(final AnActionEvent e) {
+      final EditorEx editor = myLanguageConsole.getConsoleEditor();
+      final Lookup lookup = LookupManager.getActiveLookup(editor);
+      e.getPresentation().setEnabled(!myProcessHandler.isProcessTerminated() &&
+                                     (lookup == null || !lookup.isCompletion()));
     }
-    return builder.toString();
+  }
+
+  public LanguageConsoleViewImpl getConsoleView() {
+    return myConsoleView;
   }
 
   public Project getProject() {
     return myProject;
   }
+
+  public String getConsoleTitle() {
+    return myConsoleTitle;
+  }
+
+  public String getWorkingDir() {
+    return myWorkingDir;
+  }
+
+  public ProcessHandler getProcessHandler() {
+    return myProcessHandler;
+  }
+
+  public ConsoleExecuteActionHandler getConsoleExecuteActionHandler() {
+    return myConsoleExecuteActionHandler;
+  }
 }
diff --git a/platform/lang-impl/src/com/intellij/execution/runners/ConsoleExecuteActionHandler.java b/platform/lang-impl/src/com/intellij/execution/runners/ConsoleExecuteActionHandler.java
new file mode 100644 (file)
index 0000000..55bf52f
--- /dev/null
@@ -0,0 +1,70 @@
+/*
+ * Copyright 2000-2010 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 com.intellij.execution.runners;
+
+import com.intellij.execution.console.LanguageConsoleImpl;
+import com.intellij.execution.process.ConsoleHistoryModel;
+import com.intellij.execution.process.ProcessHandler;
+import com.intellij.openapi.editor.Document;
+import com.intellij.openapi.util.TextRange;
+import com.intellij.openapi.util.text.StringUtil;
+
+import java.io.IOException;
+import java.io.OutputStream;
+
+/**
+* @author traff
+*/
+public class ConsoleExecuteActionHandler {
+  private final ProcessHandler myProcessHandler;
+
+  public ConsoleExecuteActionHandler(ProcessHandler processHandler) {
+    myProcessHandler = processHandler;
+  }
+
+
+  public void runExecuteAction(LanguageConsoleImpl languageConsole,
+                                  ConsoleHistoryModel consoleHistoryModel) {
+
+    // Process input and add to history
+    final Document document = languageConsole.getCurrentEditor().getDocument();
+    final String text = document.getText();
+    final TextRange range = new TextRange(0, document.getTextLength());
+
+    languageConsole.getCurrentEditor().getSelectionModel().setSelection(range.getStartOffset(), range.getEndOffset());
+    languageConsole.addCurrentToHistory(range, false);
+    languageConsole.setInputText("");
+    if (!StringUtil.isEmptyOrSpaces(text)) {
+      consoleHistoryModel.addToHistory(text);
+    }
+    // Send to interpreter / server
+    processLine(text);
+  }
+
+  public void processLine(String line) {
+    //final Charset charset = myProcessHandler.getCharset();
+    final OutputStream outputStream = myProcessHandler.getProcessInput();
+    try {
+      //byte[] bytes = (line + "\n").getBytes(charset.name());
+      byte[] bytes = (line + "\n").getBytes();
+      outputStream.write(bytes);
+      outputStream.flush();
+    }
+    catch (IOException e) {
+      // ignore
+    }
+  }
+}
index e7cd7fc6f74d2e6e416f697ed803472152871321..9690c8fd38d64a432de16b1efc62b044c0dc27c2 100644 (file)
@@ -37,7 +37,7 @@ import java.util.List;
  */
 public class MultipleFacetEditorHelperImpl implements MultipleFacetEditorHelper {
   private static final Logger LOG = Logger.getInstance("#com.intellij.facet.ui.MultipleFacetSettingsEditor");
-  private final List<AbstactBinding> myBindings = new ArrayList<AbstactBinding>();
+  private final List<AbstractBinding> myBindings = new ArrayList<AbstractBinding>();
 
   public void bind(@NotNull ThreeStateCheckBox common, @NotNull FacetEditor[] editors, @NotNull NotNullFunction<FacetEditor, JCheckBox> fun) {
     List<JCheckBox> checkBoxesList = new ArrayList<JCheckBox>();
@@ -70,17 +70,17 @@ public class MultipleFacetEditorHelperImpl implements MultipleFacetEditorHelper
   }
 
   public void unbind() {
-    for (AbstactBinding binding : myBindings) {
+    for (AbstractBinding binding : myBindings) {
       binding.unbind();
     }
     myBindings.clear();
   }
 
-  private static abstract class AbstactBinding {
+  private static abstract class AbstractBinding {
     public abstract void unbind();
   }
 
-  private static class CheckBoxBinding extends AbstactBinding implements ActionListener {
+  private static class CheckBoxBinding extends AbstractBinding implements ActionListener {
     private final ThreeStateCheckBox myCommon;
     private final List<JCheckBox> myCheckBoxesList;
     private final List<Boolean> myInitialValues;
@@ -132,7 +132,7 @@ public class MultipleFacetEditorHelperImpl implements MultipleFacetEditorHelper
     }
   }
 
-  private static class TextFieldBinding extends AbstactBinding {
+  private static class TextFieldBinding extends AbstractBinding {
     private final JTextField myCommon;
     private final List<JTextField> myTextFields;
     private final List<String> myInitialValues;
@@ -173,7 +173,7 @@ public class MultipleFacetEditorHelperImpl implements MultipleFacetEditorHelper
     }
   }
 
-  private static class CombobBoxBinding extends AbstactBinding implements ItemListener {
+  private static class CombobBoxBinding extends AbstractBinding implements ItemListener {
     private final JComboBox myCommon;
     private final List<JComboBox> myComponentsList;
     private final List<Object> myInitialValues;
index 05c15dd437ca862a5000bbb6b6ab139dcb5b86d8..433e464474f911a127676e6ae6b7d464f8f93595 100644 (file)
@@ -44,7 +44,7 @@ import com.intellij.psi.codeStyle.CodeStyleSettingsManager;
 import com.intellij.psi.impl.PsiTreeDebugBuilder;
 import com.intellij.psi.impl.source.codeStyle.CodeEditUtil;
 import com.intellij.psi.impl.source.codeStyle.CodeFormatterFacade;
-import com.intellij.psi.impl.source.codeStyle.Helper;
+import com.intellij.psi.impl.source.codeStyle.IndentHelper;
 import com.intellij.psi.impl.source.codeStyle.HelperFactory;
 import com.intellij.psi.impl.source.tree.*;
 import com.intellij.psi.impl.source.tree.injected.InjectedLanguageUtil;
@@ -537,25 +537,25 @@ public class PostprocessReformattingAspect implements PomModelAspect, Disposable
                                                final Document document,
                                                final TextRange[] indents,
                                                final int indentAdjustment) {
-    final Helper formatHelper = HelperFactory.createHelper(file.getFileType(), file.getProject());
+    final IndentHelper formatIndentHelper = HelperFactory.createHelper(file.getFileType(), file.getProject());
     final CharSequence charsSequence = document.getCharsSequence();
     for (final TextRange indent : indents) {
       final String oldIndentStr = charsSequence.subSequence(indent.getStartOffset() + 1, indent.getEndOffset()).toString();
-      final int oldIndent = formatHelper.getIndent(oldIndentStr, true);
-      final String newIndentStr = formatHelper.fillIndent(Math.max(oldIndent + indentAdjustment, 0));
+      final int oldIndent = formatIndentHelper.getIndent(oldIndentStr, true);
+      final String newIndentStr = formatIndentHelper.fillIndent(Math.max(oldIndent + indentAdjustment, 0));
       document.replaceString(indent.getStartOffset() + 1, indent.getEndOffset(), newIndentStr);
     }
   }
 
   private static int getNewIndent(final PsiFile psiFile, final int firstWhitespace) {
-    final Helper formatHelper = HelperFactory.createHelper(psiFile.getFileType(), psiFile.getProject());
+    final IndentHelper formatIndentHelper = HelperFactory.createHelper(psiFile.getFileType(), psiFile.getProject());
     final Document document = psiFile.getViewProvider().getDocument();
     final int startOffset = document.getLineStartOffset(document.getLineNumber(firstWhitespace));
     int endOffset = startOffset;
     final CharSequence charsSequence = document.getCharsSequence();
     while (Character.isWhitespace(charsSequence.charAt(endOffset++))) ;
     final String newIndentStr = charsSequence.subSequence(startOffset, endOffset - 1).toString();
-    return formatHelper.getIndent(newIndentStr, true);
+    return formatIndentHelper.getIndent(newIndentStr, true);
   }
 
   public boolean isDisabled() {
index 6933ac1f6a6b6a2ee5837cf424672379da179e2e..0f3143b812e84d57aea476874a92fcaa187b4b96 100644 (file)
@@ -37,7 +37,6 @@ import com.intellij.psi.impl.source.tree.TreeElement;
 import com.intellij.psi.impl.source.tree.TreeUtil;
 import com.intellij.psi.templateLanguages.OuterLanguageElement;
 import com.intellij.psi.tree.IElementType;
-import com.intellij.psi.tree.TokenSet;
 import com.intellij.psi.util.PsiUtilBase;
 import com.intellij.util.text.CharArrayUtil;
 import org.jetbrains.annotations.NotNull;
@@ -135,8 +134,8 @@ public class CodeEditUtil {
       return;
     }
     final PsiFile containingFile = psiElement.getContainingFile();
-    final Helper helper = HelperFactory.createHelper(containingFile.getFileType(), containingFile.getProject());
-    setOldIndentation((TreeElement)first, helper.getIndent(first));
+    final IndentHelper indentHelper = HelperFactory.createHelper(containingFile.getFileType(), containingFile.getProject());
+    setOldIndentation((TreeElement)first, indentHelper.getIndent(first));
   }
 
   public static int getOldIndentation(ASTNode node){
index 360233341f9ac96572738b6856e163f57dc577a8..a26fe4b5c0f471c24c6b8225cc42eda00bf94fa9 100644 (file)
@@ -307,7 +307,7 @@ public class CodeStyleManagerImpl extends CodeStyleManager {
     if (!SourceTreeToPsiMap.hasTreeElement(file)) {
       return false;
     }
-    Helper helper = HelperFactory.createHelper(file.getFileType(), myProject);
+    IndentHelper indentHelper = HelperFactory.createHelper(file.getFileType(), myProject);
     CharSequence chars = file.getViewProvider().getContents();
     int start = CharArrayUtil.shiftBackward(chars, offset - 1, " \t");
     if (start > 0 && chars.charAt(start) != '\n' && chars.charAt(start) != '\r') {
@@ -334,7 +334,7 @@ public class CodeStyleManagerImpl extends CodeStyleManager {
     }
     */
     if (getSettings().KEEP_FIRST_COLUMN_COMMENT && isCommentToken(element)) {
-      if (helper.getIndent(element, true) == 0) {
+      if (indentHelper.getIndent(element, true) == 0) {
         return false;
       }
     }
@@ -382,8 +382,8 @@ public class CodeStyleManagerImpl extends CodeStyleManager {
 
   public Indent getIndent(String text, FileType fileType) {
     int indent = HelperFactory.createHelper(fileType, myProject).getIndent(text, true);
-    int indenLevel = indent / Helper.INDENT_FACTOR;
-    int spaceCount = indent - indenLevel * Helper.INDENT_FACTOR;
+    int indenLevel = indent / IndentHelper.INDENT_FACTOR;
+    int spaceCount = indent - indenLevel * IndentHelper.INDENT_FACTOR;
     return new IndentImpl(getSettings(), indenLevel, spaceCount, fileType);
   }
 
@@ -408,7 +408,7 @@ public class CodeStyleManagerImpl extends CodeStyleManager {
         }
       }
     }
-    return HelperFactory.createHelper(fileType, myProject).fillIndent(indentLevel * Helper.INDENT_FACTOR + spaceCount);
+    return HelperFactory.createHelper(fileType, myProject).fillIndent(indentLevel * IndentHelper.INDENT_FACTOR + spaceCount);
   }
 
   public Indent zeroIndent() {
index f75ed0a169cf3fd160c35dd577a6979fddf4f7c3..e8302ccf2e32f2211f748e70eef15ad9b1c3d0f3 100644 (file)
@@ -24,20 +24,20 @@ import com.intellij.openapi.project.Project;
 
 public class HelperFactory {
   private static Factory INSTANCE = new Factory() {
-    public Helper create(final FileType fileType, final Project project) {
-      return new Helper(fileType, project);
+    public IndentHelper create(final FileType fileType, final Project project) {
+      return new IndentHelper(fileType, project);
     }
   };
 
   private HelperFactory() {
   }
 
-  public static Helper createHelper(FileType fileType, Project project) {
+  public static IndentHelper createHelper(FileType fileType, Project project) {
     return INSTANCE.create(fileType, project);
   }
 
   interface Factory {
-    Helper create(FileType fileType, Project project);
+    IndentHelper create(FileType fileType, Project project);
   }
 
   public static void setFactory(Factory factory) {
similarity index 96%
rename from platform/lang-impl/src/com/intellij/psi/impl/source/codeStyle/Helper.java
rename to platform/lang-impl/src/com/intellij/psi/impl/source/codeStyle/IndentHelper.java
index c52e532f19f465d8ee9f5a3ac948aaa2c671876c..1c36dd5905788bcdbafbbe0b7e3bc0ffbb73fbf9 100644 (file)
@@ -24,11 +24,11 @@ import com.intellij.psi.codeStyle.CodeStyleSettingsManager;
 import com.intellij.psi.impl.source.tree.CompositeElement;
 import com.intellij.psi.impl.source.tree.TreeUtil;
 
-public class Helper {
+public class IndentHelper {
   private final CodeStyleSettings mySettings;
   private final FileType myFileType;
 
-  protected Helper(FileType fileType, Project project) {
+  protected IndentHelper(FileType fileType, Project project) {
     mySettings = CodeStyleSettingsManager.getSettings(project);
     myFileType = fileType;
   }
@@ -45,10 +45,10 @@ public class Helper {
     return getIndentInner(element, includeNonSpace, 0);
   }
   
-  public static final int TOO_BIG_WALK_THRESHOULD = 450;
+  public static final int TOO_BIG_WALK_THRESHOLD = 450;
 
   protected int getIndentInner(final ASTNode element, boolean includeNonSpace, int recursionLevel) {
-    if (recursionLevel > TOO_BIG_WALK_THRESHOULD) return 0;
+    if (recursionLevel > TOO_BIG_WALK_THRESHOLD) return 0;
 
     if (element.getTreePrev() != null) {
       ASTNode prev = element.getTreePrev();
index 68d99ba6bb54637a7ebea121b8074c50fb8793f0..4bd59d27ff5d8ce7c45867530a70d621ad0a4ed0 100644 (file)
@@ -15,6 +15,8 @@
  */
 package com.intellij.execution.process;
 
+import com.intellij.openapi.util.io.FileUtil;
+import com.intellij.openapi.util.text.StringUtil;
 import org.jetbrains.annotations.Nullable;
 
 import java.util.Map;
@@ -22,14 +24,27 @@ import java.util.Map;
 /**
  * @author Roman.Chernyatchik, oleg
  */
-public interface CommandLineArgumentsProvider {
+public abstract class CommandLineArgumentsProvider {
     /**
    * @return Commands to execute (one command corresponds to one add argument)
    */
-  String[] getArguments();
+  public abstract String[] getArguments();
 
-  boolean passParentEnvs();
+  public abstract boolean passParentEnvs();
 
   @Nullable
-  Map<String, String> getAdditionalEnvs();
+  public abstract Map<String, String> getAdditionalEnvs();
+
+
+  public String getCommandLineString() {
+    return toCommandLine(getArguments());
+  }
+
+  public static String toCommandLine(String... commands) {
+    if (commands.length > 0) {
+      commands[0] = FileUtil.toSystemDependentName(commands[0]);
+      return StringUtil.join(commands, " ");
+    }
+    return "";
+  }
 }
index ca5d6b25af41f7b51993c1b181a8744ada63a8a6..d53322c674488218297e1e48da698375cff7f975 100644 (file)
@@ -48,10 +48,10 @@ public class AbstractMethodWithMissingImplementationsInspection
     }
 
     public BaseInspectionVisitor buildVisitor() {
-        return new AbstactMethodWithMissingImplementationsVisitor();
+        return new AbstractMethodWithMissingImplementationsVisitor();
     }
 
-    private static class AbstactMethodWithMissingImplementationsVisitor
+    private static class AbstractMethodWithMissingImplementationsVisitor
             extends BaseInspectionVisitor {
 
         @Override public void visitMethod(PsiMethod method) {
index 533d124299d6868e2ab160f90ecb79eb274c625f..54dd2104de3c9686a1de1417c531353869229717 100644 (file)
@@ -22,7 +22,7 @@ package com.intellij.lang.html;
 import com.intellij.codeInsight.completion.CompletionUtil;
 import com.intellij.codeInsight.daemon.XmlErrorMessages;
 import com.intellij.lang.PsiBuilder;
-import com.intellij.psi.impl.source.codeStyle.Helper;
+import com.intellij.psi.impl.source.codeStyle.IndentHelper;
 import com.intellij.psi.tree.CustomParsingType;
 import com.intellij.psi.tree.IElementType;
 import com.intellij.psi.tree.ILazyParseableElementType;
@@ -615,5 +615,5 @@ public class HtmlParsing {
     myBuilder.error(message);
   }
 
-  private static final int MAGIC_FRAME_COUNT = Helper.TOO_BIG_WALK_THRESHOULD + (int)(Math.pow(Math.E, Math.PI) * Math.sin(Math.random()));
+  private static final int MAGIC_FRAME_COUNT = IndentHelper.TOO_BIG_WALK_THRESHOLD + (int)(Math.pow(Math.E, Math.PI) * Math.sin(Math.random()));
 }