com.intellij.execution.BeforeRunTask Java Examples

protected void assertAndRunPantsMake(JUnitConfiguration runConfiguration) {

    RunManager runManager = RunManager.getInstance(myProject);
    assertTrue(runManager instanceof RunManagerImpl);
    RunManagerImpl runManagerImpl = (RunManagerImpl) runManager;

    RunnerAndConfigurationSettings runnerAndConfigurationSettings =
      runManagerImpl.createConfiguration(runConfiguration, JUnitConfigurationType.getInstance().getConfigurationFactories()[0]);
    runManagerImpl.addConfiguration(runnerAndConfigurationSettings, false);

    // Make sure PantsMake is the one and only task before JUnit run.
    List<BeforeRunTask<?>> beforeRunTaskList = runManagerImpl.getBeforeRunTasks(runConfiguration);
    assertEquals(1, beforeRunTaskList.size());
    BeforeRunTask task = beforeRunTaskList.iterator().next();
    assertEquals(PantsMakeBeforeRun.ID, task.getProviderId());

    /*
     * Manually invoke BeforeRunTask as {@link ExecutionManager#compileAndRun} launches another task asynchronously,
     * and there is no way to catch that.
     */
    BeforeRunTaskProvider provider = BeforeRunTaskProvider.getProvider(myProject, task.getProviderId());
    assertNotNull(String.format("Cannot find BeforeRunTaskProvider for id='%s'", task.getProviderId()), provider);
    assertTrue(provider.executeTask(null, runConfiguration, null, task));
  }
 

private boolean checkBeforeRunTasksAbility(boolean checkOnlyAddAction) {
  if (isUnknown()) {
    return false;
  }
  Set<Key> activeProviderKeys = getActiveProviderKeys();
  final BeforeRunTaskProvider<BeforeRunTask>[] providers = Extensions.getExtensions(BeforeRunTaskProvider.EP_NAME, myRunConfiguration.getProject());
  for (final BeforeRunTaskProvider<BeforeRunTask> provider : providers) {
    if (provider.createTask(myRunConfiguration) != null) {
      if (!checkOnlyAddAction) {
        return true;
      }
      else if (!provider.isSingleton() || !activeProviderKeys.contains(provider.getId())) {
        return true;
      }
    }
  }
  return false;
}
 

private boolean canBeAdded(@Nonnull RunConfiguration candidate, @Nonnull final CompoundRunConfiguration root) {
  if (candidate.getType() == root.getType() && candidate.getName().equals(root.getName())) return false;
  List<BeforeRunTask> tasks = myRunManager.getBeforeRunTasks(candidate);
  for (BeforeRunTask task : tasks) {
    if (task instanceof RunConfigurationBeforeRunProvider.RunConfigurableBeforeRunTask) {
      RunConfigurationBeforeRunProvider.RunConfigurableBeforeRunTask runTask
              = (RunConfigurationBeforeRunProvider.RunConfigurableBeforeRunTask)task;
      RunnerAndConfigurationSettings settings = runTask.getSettings();
      if (settings != null) {
        if (!canBeAdded(settings.getConfiguration(), root)) return false;
      }
    }
  }
  if (candidate instanceof CompoundRunConfiguration) {
    Set<RunConfiguration> set = ((CompoundRunConfiguration)candidate).getSetToRun();
    for (RunConfiguration configuration : set) {
      if (!canBeAdded(configuration, root)) return false;
    }
  }
  return true;
}
 

private static boolean addBlazeBeforeRunTask(BlazeCommandRunConfiguration config) {
  BeforeRunTaskProvider<?> provider =
      BlazeBeforeRunTaskProvider.getProvider(config.getProject(), BlazeBeforeRunTaskProvider.ID);
  if (provider == null) {
    return false;
  }
  BeforeRunTask<?> task = provider.createTask(config);
  if (task == null) {
    return false;
  }
  task.setEnabled(true);

  List<BeforeRunTask<?>> beforeRunTasks = new ArrayList<>(config.getBeforeRunTasks());
  beforeRunTasks.add(task);
  config.setBeforeRunTasks(beforeRunTasks);

  return true;
}
 

private static boolean enableBlazeBeforeRunTask(BlazeCommandRunConfiguration config) {
  @SuppressWarnings("rawtypes")
  List<BeforeRunTask> tasks =
      RunManagerEx.getInstanceEx(config.getProject()).getBeforeRunTasks(config);
  if (tasks.stream().noneMatch(t -> t.getProviderId().equals(BlazeBeforeRunTaskProvider.ID))) {
    return addBlazeBeforeRunTask(config);
  }
  boolean changed = false;
  for (BeforeRunTask<?> task : tasks) {
    if (task.getProviderId().equals(BlazeBeforeRunTaskProvider.ID) && !task.isEnabled()) {
      changed = true;
      task.setEnabled(true);
    }
  }
  return changed;
}
 

@Override
protected void customizeCellRenderer(@Nonnull JList<? extends BeforeRunTask> list, BeforeRunTask value, int index, boolean selected, boolean hasFocus) {
  BeforeRunTaskProvider<BeforeRunTask> provider = BeforeRunTaskProvider.getProvider(myRunConfiguration.getProject(), value.getProviderId());
  if (provider != null) {
    setIcon(provider.getTaskIcon(value));
    append(provider.getDescription(value));
  }
}
 

private void getAllRunBeforeRuns(BeforeRunTask task, Set<RunConfiguration> configurationSet) {
  if (task instanceof RunConfigurationBeforeRunProvider.RunConfigurableBeforeRunTask) {
    RunConfigurationBeforeRunProvider.RunConfigurableBeforeRunTask runTask = (RunConfigurationBeforeRunProvider.RunConfigurableBeforeRunTask)task;
    RunConfiguration configuration = runTask.getSettings().getConfiguration();

    List<BeforeRunTask> tasks = RunManagerImpl.getInstanceImpl(configuration.getProject()).getBeforeRunTasks(configuration);
    for (BeforeRunTask beforeRunTask : tasks) {
      if (beforeRunTask instanceof RunConfigurationBeforeRunProvider.RunConfigurableBeforeRunTask) {
        if (configurationSet.add(((RunConfigurationBeforeRunProvider.RunConfigurableBeforeRunTask)beforeRunTask).getSettings().getConfiguration())) {
          getAllRunBeforeRuns(beforeRunTask, configurationSet);
        }
      }
    }
  }
}
 

private Set<Key> getActiveProviderKeys() {
  Set<Key> result = new HashSet<>();
  for (BeforeRunTask task : myModel.getItems()) {
    result.add(task.getProviderId());
  }
  return result;
}
 

private List<BeforeRunTask<?>> getBeforeRunTask(RunConfiguration configuration) {
  RunManagerImpl runManager = (RunManagerImpl) RunManager.getInstance(myProject);
  RunnerAndConfigurationSettingsImpl configurationSettings = new RunnerAndConfigurationSettingsImpl(runManager, configuration, true);
  runManager.addConfiguration(configurationSettings, true);
  List<BeforeRunTask<?>> tasks = runManager.getBeforeRunTasks(configuration);
  runManager.removeConfiguration(configurationSettings);
  return tasks;
}
 

/**
 * 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);
}
 

public static void replaceDefaultMakeWithPantsMake(@NotNull RunConfiguration runConfiguration) {
  if (!PantsUtil.isScalaRelatedTestRunConfiguration(runConfiguration) &&
      !(runConfiguration instanceof CommonProgramRunConfigurationParameters)) {
    return;
  }

  RunManager runManager = RunManager.getInstance(runConfiguration.getProject());
  RunManagerImpl runManagerImpl = (RunManagerImpl) runManager;
  BeforeRunTask pantsMakeTask = new ExternalSystemBeforeRunTask(ID, PantsConstants.SYSTEM_ID);
  pantsMakeTask.setEnabled(true);
  runManagerImpl.setBeforeRunTasks(runConfiguration, Collections.singletonList(pantsMakeTask));
}
 

@Nullable
private Pair<BeforeRunTask, BeforeRunTaskProvider<BeforeRunTask>> getSelection() {
  final int index = myList.getSelectedIndex();
  if (index == -1) return null;
  BeforeRunTask task = myModel.getElementAt(index);
  Key providerId = task.getProviderId();
  BeforeRunTaskProvider<BeforeRunTask> provider = BeforeRunTaskProvider.getProvider(myRunConfiguration.getProject(), providerId);
  return provider != null ? Pair.create(task, provider) : null;
}
 

public List<BeforeRunTask> getTasks(boolean applyCurrentState) {
  if (applyCurrentState) {
    originalTasks.clear();
    originalTasks.addAll(myModel.getItems());
  }
  return Collections.unmodifiableList(originalTasks);
}
 

public void addBeforeLaunchStep(BeforeRunTask<?> task) {
  myBeforeRunStepsPanel.addTask(task);
}
 

@Override
public BeforeRunTask clone() {
  final AbstractArtifactsBeforeRunTask task = (AbstractArtifactsBeforeRunTask)super.clone();
  task.myArtifactPointers = new ArrayList<ArtifactPointer>(myArtifactPointers);
  return task;
}
 

public void addTask(BeforeRunTask task) {
  myModel.add(task);
}
 

void doAddAction(AnActionButton button) {
  if (isUnknown()) {
    return;
  }

  final JBPopupFactory popupFactory = JBPopupFactory.getInstance();
  final List<BeforeRunTaskProvider<BeforeRunTask>> providers = BeforeRunTaskProvider.EP_NAME.getExtensionList(myRunConfiguration.getProject());
  Set<Key> activeProviderKeys = getActiveProviderKeys();

  DefaultActionGroup actionGroup = new DefaultActionGroup(null, false);
  for (final BeforeRunTaskProvider<BeforeRunTask> provider : providers) {
    if (provider.createTask(myRunConfiguration) == null) continue;
    if (activeProviderKeys.contains(provider.getId()) && provider.isSingleton()) continue;
    AnAction providerAction = new AnAction(provider.getName(), null, provider.getIcon()) {
      @RequiredUIAccess
      @Override
      public void actionPerformed(@Nonnull AnActionEvent e) {
        BeforeRunTask task = provider.createTask(myRunConfiguration);
        if (task == null) {
          return;
        }

        provider.configureTask(myRunConfiguration, task).doWhenProcessed(() -> {
          if (!provider.canExecuteTask(myRunConfiguration, task)) return;
          task.setEnabled(true);

          Set<RunConfiguration> configurationSet = new HashSet<>();
          getAllRunBeforeRuns(task, configurationSet);
          if (configurationSet.contains(myRunConfiguration)) {
            JOptionPane.showMessageDialog(BeforeRunStepsPanel.this,
                                          ExecutionBundle.message("before.launch.panel.cyclic_dependency_warning", myRunConfiguration.getName(), provider.getDescription(task)),
                                          ExecutionBundle.message("warning.common.title"), JOptionPane.WARNING_MESSAGE);
            return;
          }
          addTask(task);
          myListener.fireStepsBeforeRunChanged();
        });
      }
    };
    actionGroup.add(providerAction);
  }
  final ListPopup popup = popupFactory
          .createActionGroupPopup(ExecutionBundle.message("add.new.run.configuration.acrtion.name"), actionGroup, SimpleDataContext.getProjectContext(myRunConfiguration.getProject()), false, false,
                                  false, null, -1, Condition.TRUE);
  popup.show(button.getPreferredPopupPoint());
}
 

public List<BeforeRunTask> getStepsBeforeLaunch() {
  return Collections.unmodifiableList(myBeforeRunStepsPanel.getTasks(true));
}
 

@Override
public BeforeRunTask clone() {
  return super.clone();
}
 

@Override
public void configureBeforeRunTaskDefaults(Key<? extends BeforeRunTask> providerID, BeforeRunTask task)
{
    super.configureBeforeRunTaskDefaults(providerID, task);
}
 

@Override
public void onNewConfigurationCreated(@NotNull RunConfiguration configuration) {
    //the last param has to be false because we do not want a fallback to the template (we're creating it right now) (avoiding a SOE)
    RunManagerEx.getInstanceEx(configuration.getProject()).setBeforeRunTasks(configuration, Collections.<BeforeRunTask>emptyList(), false);
}
 

@Override
public void configureBeforeRunTaskDefaults(
    Key<? extends BeforeRunTask> providerID, BeforeRunTask task) {
  task.setEnabled(providerID.equals(BuildPluginBeforeRunTaskProvider.ID));
}
 

@Override
public void configureBeforeRunTaskDefaults(
    Key<? extends BeforeRunTask> providerID, BeforeRunTask task) {
  task.setEnabled(providerID.equals(BlazeBeforeRunTaskProvider.ID));
}
 

/** Overridden to stop providing Grade tasks from superclasses */
@Override
public List<BeforeRunTask<?>> getBeforeRunTasks() {
  return Collections.emptyList();
}
 

/** Overridden to stop providing Grade tasks from superclasses */
@Override
public List<BeforeRunTask<?>> getBeforeRunTasks() {
  return Collections.emptyList();
}
 

@Override
public void configureBeforeRunTaskDefaults(Key<? extends BeforeRunTask> providerID, BeforeRunTask task)
{
    super.configureBeforeRunTaskDefaults(providerID, task);
}
 

/**
 * In this method you can configure defaults for the task, which are preferable to be used for your particular configuration type
 *
 * @param providerID
 * @param task
 */
public void configureBeforeRunTaskDefaults(Key<? extends BeforeRunTask> providerID, BeforeRunTask task) {
}