com.intellij.execution.configurations.ModuleBasedConfiguration Java Examples

public void executeConfiguration(Project project, ModuleBasedConfiguration appCon) {
    if (noProjectsAreOpen()) {
        logger.warn("No open projects found, can't execute the project.");
        return;
    }
    logger.info("Starting to build execution environment.");
    RunManager runManager = RunManager.getInstance(project);
    Executor executor = DefaultRunExecutor.getRunExecutorInstance();
    RunnerAndConfigurationSettingsImpl selectedConfiguration =
            getApplicationRunnerAndConfigurationSettings(runManager, appCon);
    ProgramRunner runner = getRunner(executor, selectedConfiguration);
    logger.info("Creating ExecutionEnvironment.");
    ExecutionEnvironment environment =
            new ExecutionEnvironment(
                    new DefaultRunExecutor(), runner, selectedConfiguration, project);
    try {
        logger.info("Executing project.");
        runner.execute(environment);
    } catch (ExecutionException e1) {
        JavaExecutionUtil.showExecutionErrorMessage(e1, "Error", project);
    }
}
 

private static ProcessingItem[] run(CompileContext context,
                                    ProcessingItem[] items,
                                    ModuleBasedConfiguration configuration) {
  final Module module = configuration.getConfigurationModule().getModule();
  if (module == null) {
    context.addMessage(CompilerMessageCategory.ERROR,
                       HaxeBundle.message("no.module.for.run.configuration", configuration.getName()), null, -1, -1);
    return ProcessingItem.EMPTY_ARRAY;
  }
  HaxeCommonCompilerUtil.CompilationContext compilationContext = createCompilationContext(context, module, configuration);

  if (compileModule(context, module, compilationContext)) {
    final int index = findProcessingItemIndexByModule(items, configuration.getConfigurationModule());
    if (index != -1) {
      return new ProcessingItem[]{items[index]};
    }
  }
  return ProcessingItem.EMPTY_ARRAY;
}
 

@Nullable
private CoverageSuitesBundle getCurrentCoverageSuite() {
  if (myModel == null) {
    return null;
  }

  final RunProfile runConf = myModel.getProperties().getConfiguration();
  if (runConf instanceof ModuleBasedConfiguration) {

    // if coverage supported for run configuration
    if (CoverageEnabledConfiguration.isApplicableTo((ModuleBasedConfiguration) runConf)) {

      // Get coverage settings
      Executor executor = myProperties.getExecutor();
      if (executor != null && executor.getId().equals(CoverageExecutor.EXECUTOR_ID)) {
        return CoverageDataManager.getInstance(myProperties.getProject()).getCurrentSuitesBundle();
      }
    }
  }
  return null;
}
 

@NotNull
private RunnerAndConfigurationSettingsImpl getApplicationRunnerAndConfigurationSettings(
        RunManager runManager, ModuleBasedConfiguration appCon) {
    logger.info("Getting RunnerAndConfigurationSettings implementation.");
    return new RunnerAndConfigurationSettingsImpl(
            (RunManagerImpl) runManager,
            appCon,
            runManager.getSelectedConfiguration().isTemplate());
}
 

@Nullable
protected Module getModule(CommonProgramRunConfigurationParameters configuration) {
  if (configuration instanceof ModuleBasedConfiguration) {
    return ((ModuleBasedConfiguration)configuration).getConfigurationModule().getModule();
  }
  return null;
}
 

private GlobalSearchScope getSearchScopeInner(Project project) {
  final RunConfigurationBase configuration = getRunConfiguration();
  if (configuration instanceof ModuleBasedConfiguration) {
    final Module module = ((ModuleBasedConfiguration)configuration).getConfigurationModule().getModule();
    if (module != null) {
      return GlobalSearchScope.moduleRuntimeScope(module, isTrackTestFolders());
    }
  }
  return isTrackTestFolders() ? GlobalSearchScope.projectScope(project) : GlobalSearchScopesCore.projectProductionScope(project);
}
 

private void setupConfigurationModule(@Nullable ConfigurationContext context,
                                      ModuleBasedConfiguration configuration) {
    if (context != null) {
        Module module = getModule(context, configuration);
        if (module != null) {
            configuration.setModule(module);
        }
    }
}
 

public void reset(final ModuleBasedConfiguration configuration) {
    final Module[] modules = ModuleManager.getInstance(getProject()).getModules();
    final List<Module> list = new ArrayList<>();
    for (final Module module : modules) {
        if (isModuleAccepted(module)) list.add(module);
    }
    setModules(list);
    myModulesList.setSelectedItem(configuration.getConfigurationModule().getModule());
}
 

@Override
public ProcessingItem[] process(CompileContext context, ProcessingItem[] items) {
  final RunConfiguration runConfiguration = CompileStepBeforeRun.getRunConfiguration(context.getCompileScope());
  if (runConfiguration instanceof ModuleBasedConfiguration) {
    return run(context, items, (ModuleBasedConfiguration)runConfiguration);
  }
  return make(context, items);
}
 

@Nullable
private <T extends RunConfigurationBase> Module findPantsModule(T configuration) {
  if (!(configuration instanceof ModuleBasedConfiguration)) {
    return null;
  }
  final RunConfigurationModule runConfigurationModule = ((ModuleBasedConfiguration) configuration).getConfigurationModule();
  final Module module = runConfigurationModule.getModule();
  if (module == null || !PantsUtil.isPantsModule(module)) {
    return null;
  }
  return module;
}
 

public void applyTo(final ModuleBasedConfiguration configurationModule) {
    configurationModule.setModule((Module) myModulesList.getSelectedItem());
}
 

@Override
protected ModuleBasedConfiguration createInstance() {
    return new XQueryRunConfiguration(getName(), new XQueryRunConfigurationModule(getProject()),
            XQueryRunConfigurationType.getInstance().getConfigurationFactories()[0]);
}
 

private Module getModule(ConfigurationContext context, ModuleBasedConfiguration configuration) {
    Module module = getPredefinedModule(context);
    if (module == null)
        module = getModuleForLocation(context, configuration);
    return module;
}
 

private Module getModuleForLocation(ConfigurationContext context, ModuleBasedConfiguration configuration) {
    final Module contextModule = context.getModule();
    return findModule(configuration, contextModule);
}
 

private Module findModule(ModuleBasedConfiguration configuration, Module contextModule) {
    if (configuration.getConfigurationModule().getModule() == null && contextModule != null) {
        return contextModule;
    }
    return null;
}
 

private Module getPredefinedModule(RunnerAndConfigurationSettings template) {
    return ((ModuleBasedConfiguration) template.getConfiguration()).getConfigurationModule().getModule();
}
 

private Module getModule(CommonProgramRunConfigurationParameters configuration) {
    return configuration instanceof ModuleBasedConfiguration ? ((ModuleBasedConfiguration) configuration).getConfigurationModule().getModule() : null;
}
 

public SourceScope getSourceScope(final ModuleBasedConfiguration configuration) {
  return SourceScope.wholeProject(configuration.getProject());
}
 

public SourceScope getSourceScope(final ModuleBasedConfiguration configuration) {
  return SourceScope.modules(configuration.getModules());
}
 

public SourceScope getSourceScope(final ModuleBasedConfiguration configuration) {
  return SourceScope.modulesWithDependencies(configuration.getModules());
}
 

@Override
protected ModuleBasedConfiguration createInstance() {
  return new HaxeApplicationConfiguration(getName(), getProject(), HaxeRunConfigurationType.getInstance());
}
 

SourceScope getSourceScope(ModuleBasedConfiguration configuration);