com.intellij.execution.configurations.RunnerSettings Java Examples

ExecutionEnvironment(@Nonnull RunProfile runProfile,
                     @Nonnull Executor executor,
                     @Nonnull ExecutionTarget target,
                     @Nonnull Project project,
                     @Nullable RunnerSettings runnerSettings,
                     @Nullable ConfigurationPerRunnerSettings configurationSettings,
                     @javax.annotation.Nullable RunContentDescriptor contentToReuse,
                     @Nullable RunnerAndConfigurationSettings settings,
                     @Nonnull ProgramRunner<?> runner) {
  myExecutor = executor;
  myTarget = target;
  myRunProfile = runProfile;
  myRunnerSettings = runnerSettings;
  myConfigurationSettings = configurationSettings;
  myProject = project;
  setContentToReuse(contentToReuse);
  myRunnerAndConfigurationSettings = settings;

  myRunner = runner;
}
 

/** #api193: remove when 2019.3 no longer supported; default implementation added in 2020.1. */
@Nullable
@Override
public RunnerSettings createConfigurationData(
    ConfigurationInfoProvider configurationInfoProvider) {
  return null;
}
 

/**
 * @deprecated, use {@link com.intellij.execution.runners.ExecutionEnvironmentBuilder} instead
 * to remove in IDEA 15
 */
public ExecutionEnvironment(@Nonnull RunProfile runProfile,
                            @Nonnull Executor executor,
                            @Nonnull Project project,
                            @Nullable RunnerSettings runnerSettings) {
  //noinspection ConstantConditions
  this(runProfile, executor, DefaultExecutionTarget.INSTANCE, project, runnerSettings, null, null, null, RunnerRegistry.getInstance().getRunner(executor.getId(), runProfile));
}
 

@Nonnull
protected List<T> getEnabledExtensions(@Nonnull U configuration, @javax.annotation.Nullable RunnerSettings runnerSettings) {
  List<T> extensions = new SmartList<>();
  for (T extension : myExtensionPointName.getExtensionList()) {
    if (extension.isApplicableFor(configuration) && extension.isEnabledFor(configuration, runnerSettings)) {
      extensions.add(extension);
    }
  }
  return extensions;
}
 

public void attachExtensionsToProcess(@Nonnull final U configuration,
                                      @Nonnull final ProcessHandler handler,
                                      RunnerSettings runnerSettings) {
  // only for enabled extensions
  for (T extension : getEnabledExtensions(configuration, runnerSettings)) {
    extension.attachToProcess(configuration, handler, runnerSettings);
  }
}
 

public void patchCommandLine(@Nonnull final U configuration,
                             final RunnerSettings runnerSettings,
                             @Nonnull final GeneralCommandLine cmdLine,
                             @Nonnull final String runnerId) throws ExecutionException {
  // only for enabled extensions
  for (T extension : getEnabledExtensions(configuration, runnerSettings)) {
    extension.patchCommandLine(configuration, runnerSettings, cmdLine, runnerId);
  }
}
 

@Override
public void attachToProcess(@Nonnull final ProcessHandler handler, @Nonnull final RunConfigurationBase configuration, final RunnerSettings runnerSettings) {
  handler.addProcessListener(new ProcessAdapter() {
    @Override
    public void processTerminated(final ProcessEvent event) {
      processGatheredCoverage(configuration, runnerSettings);
    }
  });
}
 

public static void attachToProcess(@Nonnull RunConfigurationBase configuration,
                                   @Nonnull ProcessHandler handler,
                                   RunnerSettings runnerSettings) {
  resetCoverageSuit(configuration);

  // attach to process termination listener
  CoverageDataManager.getInstance(configuration.getProject()).attachToProcess(handler, configuration, runnerSettings);
}
 

private MyConsoleView(final TestConsoleProperties consoleProperties, final RunnerSettings runnerSettings,
                      final ConfigurationPerRunnerSettings configurationPerRunnerSettings) {
  super(consoleProperties, "SMTRunnerConsoleTest");

  myTestsOutputConsolePrinter = new TestsOutputConsolePrinter(MyConsoleView.this, consoleProperties, null) {
    @Override
    public void print(final String text, final ConsoleViewContentType contentType) {
      myMockResettablePrinter.print(text, contentType);
    }
  };
}
 

/**
 * The goal of this function is to find classpath for IntelliJ JUnit/Scala runner.
 * <p/>
 * This function will fail if the projects' Pants doesn't support `--export-classpath-manifest-jar-only`.
 * It also assumes that Pants has created a manifest jar that contains all the classpath links for the
 * particular test that's being run.
 */
@Override
public <T extends RunConfigurationBase> void updateJavaParameters(
  T configuration,
  @NotNull JavaParameters params,
  RunnerSettings runnerSettings
) throws ExecutionException {
  List<BeforeRunTask<?>> tasks = ((RunManagerImpl) RunManager.getInstance(configuration.getProject())).getBeforeRunTasks(configuration);
  boolean builtByPants = tasks.stream().anyMatch(s -> s.getProviderId().equals(PantsMakeBeforeRun.ID));
  // Not built by Pants means it was built by IntelliJ, in which case we don't need to change the classpath.
  if (!builtByPants) {
    return;
  }

  final Module module = findPantsModule(configuration);
  if (module == null) {
    return;
  }

  Set<String> pathsAllowed = calculatePathsAllowed(params);

  final PathsList classpath = params.getClassPath();
  List<String> classpathToKeep = classpath.getPathList().stream()
    .filter(cp -> pathsAllowed.stream().anyMatch(cp::contains)).collect(Collectors.toList());
  classpath.clear();
  classpath.addAll(classpathToKeep);

  VirtualFile manifestJar = PantsUtil.findProjectManifestJar(configuration.getProject())
    .orElseThrow(() -> new ExecutionException("manifest.jar is not found. It should be generated by `./pants export-classpath ...`"));
  classpath.add(manifestJar.getPath());

  PantsExternalMetricsListenerManager.getInstance().logTestRunner(configuration);
}
 

@Override
public void patch(
    JavaParameters javaParameters,
    RunnerSettings runnerSettings,
    RunProfile runProfile,
    final boolean beforeExecution) {
  // We don't want to support Java run configuration patching.
}
 

/** #api193: remove when 2019.3 no longer supported; default implementation added in 2020.1. */
@Nullable
@Override
public SettingsEditor<RunnerSettings> getSettingsEditor(
    Executor executor, RunConfiguration runConfiguration) {
  return null;
}
 

@Nullable
@Override
public RunnerSettings getRunnerSettings(@NotNull ProgramRunner runner) {
  return null;
}
 

@Override
public RunnerSettings createConfigurationData(final ConfigurationInfoProvider settingsProvider) {
  return new CoverageRunnerData();
}
 

@Override
public void processGatheredCoverage(@Nonnull RunConfigurationBase configuration, RunnerSettings runnerSettings) {
  if (runnerSettings instanceof CoverageRunnerData) {
    processGatheredCoverage(configuration);
  }
}
 

/** #api193: remove when 2019.3 no longer supported; default implementation added in 2020.1. */
@Override
public void onProcessStarted(RunnerSettings runnerSettings, ExecutionResult executionResult) {}
 

/** #api193: remove when 2019.3 no longer supported; default implementation added in 2020.1. */
@Override
public void checkConfiguration(
    RunnerSettings runnerSettings,
    @Nullable ConfigurationPerRunnerSettings configurationPerRunnerSettings) {}
 

@Override
public boolean isEnabledFor(@NotNull AbstractPythonRunConfiguration applicableConfiguration, @Nullable RunnerSettings runnerSettings) {
    return true;
}
 

@Nullable
public RunnerSettings getRunnerSettings() {
  return myRunnerSettings;
}
 

private JComponent createCompositePerRunnerSettings(final Executor executor, final ProgramRunner runner) {
  final SettingsEditor<ConfigurationPerRunnerSettings> configEditor = myConfiguration.getRunnerSettingsEditor(runner);
  SettingsEditor<RunnerSettings> runnerEditor;

  try {
    runnerEditor = runner.getSettingsEditor(executor, myConfiguration);
  }
  catch (AbstractMethodError error) {
    // this is stub code for plugin compatibility!
    runnerEditor = null;
  }

  if (configEditor == null && runnerEditor == null) return null;
  SettingsEditor<RunnerAndConfigurationSettings> wrappedConfigEditor = null;
  SettingsEditor<RunnerAndConfigurationSettings> wrappedRunEditor = null;
  if (configEditor != null) {
    wrappedConfigEditor = new SettingsEditorWrapper<RunnerAndConfigurationSettings, ConfigurationPerRunnerSettings>(configEditor,
                                                                                                                    new Convertor<RunnerAndConfigurationSettings, ConfigurationPerRunnerSettings>() {
                                                                                                                      @Override
                                                                                                                      public ConfigurationPerRunnerSettings convert(RunnerAndConfigurationSettings configurationSettings) {
                                                                                                                        return configurationSettings.getConfigurationSettings(runner);
                                                                                                                      }
                                                                                                                    });
    myRunnerEditors.add(wrappedConfigEditor);
    Disposer.register(this, wrappedConfigEditor);
  }

  if (runnerEditor != null) {
    wrappedRunEditor = new SettingsEditorWrapper<RunnerAndConfigurationSettings, RunnerSettings>(runnerEditor,
                                                                                                 new Convertor<RunnerAndConfigurationSettings, RunnerSettings>() {
                                                                                                   @Override
                                                                                                   public RunnerSettings convert(RunnerAndConfigurationSettings configurationSettings) {
                                                                                                     return configurationSettings.getRunnerSettings(runner);
                                                                                                   }
                                                                                                 });
    myRunnerEditors.add(wrappedRunEditor);
    Disposer.register(this, wrappedRunEditor);
  }

  if (wrappedRunEditor != null && wrappedConfigEditor != null) {
    JPanel panel = new JPanel(new BorderLayout());
    panel.add(wrappedConfigEditor.getComponent(), BorderLayout.CENTER);
    JComponent wrappedRunEditorComponent = wrappedRunEditor.getComponent();
    wrappedRunEditorComponent.setBorder(IdeBorderFactory.createEmptyBorder(3, 0, 0, 0));
    panel.add(wrappedRunEditorComponent, BorderLayout.SOUTH);
    return panel;
  }

  if (wrappedRunEditor != null) return wrappedRunEditor.getComponent();
  return wrappedConfigEditor.getComponent();
}
 

/**
 * This method attach process listener to process handler. Listener will load coverage information after process termination
 * @param handler
 * @param configuration
 * @param runnerSettings
 */
public abstract void attachToProcess(@Nonnull final ProcessHandler handler,
                                     @Nonnull final RunConfigurationBase configuration, RunnerSettings runnerSettings);
 

/**
 *
 * @param applicableConfiguration Applicable run configuration
 * @return True if extension is turned on in configuration extension settings.
 *         E.g. RCov is turned on for given run configuration.
 */
protected abstract boolean isEnabledFor(@Nonnull final T applicableConfiguration, @Nullable RunnerSettings runnerSettings);
 

/**
 * Patches the command line of the process about to be started by the underlying run configuration.
 *
 * @param configuration  the underlying run configuration.
 * @param runnerSettings the runner-specific settings.
 * @param cmdLine        the command line of the process about to be started.
 * @param runnerId       the ID of the {@link com.intellij.execution.runners.ProgramRunner} used to start the process.
 * @throws ExecutionException if there was an error configuring the command line and the execution should be canceled.
 */
protected abstract void patchCommandLine(@Nonnull final T configuration,
                                         @javax.annotation.Nullable RunnerSettings runnerSettings,
                                         @Nonnull final GeneralCommandLine cmdLine,
                                         @Nonnull final String runnerId) throws ExecutionException;
 

/**
 * Attaches the extension to a process that has been started.
 *
 * @param configuration  the underlying run configuration.
 * @param handler        the ProcessHandler for the running process.
 * @param runnerSettings the runner-specific settings.
 */
protected void attachToProcess(@Nonnull final T configuration,
                               @Nonnull final ProcessHandler handler,
                               @javax.annotation.Nullable RunnerSettings runnerSettings) {

}
 

public abstract void processGatheredCoverage(@Nonnull RunConfigurationBase configuration, RunnerSettings runnerSettings);