public void generateBuildConfiguration(@NotNull final CompileContext context) {

    if (shouldBeBuiltByExternalSystem(myProject)) return;

    if (!hasGradleModules(context)) return;

    final BuildManager buildManager = BuildManager.getInstance();
    final File projectSystemDir = buildManager.getProjectSystemDirectory(myProject);
    if (projectSystemDir == null) return;

    final File gradleConfigFile =
        new File(projectSystemDir, GradleProjectConfiguration.CONFIGURATION_FILE_RELATIVE_PATH);

    final Map<String, GradleModuleResourceConfiguration> affectedGradleModuleConfigurations =
        generateAffectedGradleModulesConfiguration(context);

    if (affectedGradleModuleConfigurations.isEmpty()) return;

    boolean configurationUpdateRequired = context.isRebuild() || !gradleConfigFile.exists();

    final Map<String, Integer> affectedConfigurationHash = new THashMap<String, Integer>();
    for (Map.Entry<String, GradleModuleResourceConfiguration> entry :
        affectedGradleModuleConfigurations.entrySet()) {
      Integer moduleLastConfigurationHash = myModulesConfigurationHash.get(entry.getKey());
      int moduleCurrentConfigurationHash = entry.getValue().computeConfigurationHash();
      if (moduleLastConfigurationHash == null
          || moduleLastConfigurationHash.intValue() != moduleCurrentConfigurationHash) {
        configurationUpdateRequired = true;
      }
      affectedConfigurationHash.put(entry.getKey(), moduleCurrentConfigurationHash);
    }

    final GradleProjectConfiguration projectConfig = loadLastConfiguration(gradleConfigFile);

    // update with newly generated configuration
    projectConfig.moduleConfigurations.putAll(affectedGradleModuleConfigurations);

    final Document document = new Document(new Element("gradle-project-configuration"));
    XmlSerializer.serializeInto(projectConfig, document.getRootElement());
    final boolean finalConfigurationUpdateRequired = configurationUpdateRequired;
    buildManager.runCommand(
        new Runnable() {
          @Override
          public void run() {
            if (finalConfigurationUpdateRequired) {
              buildManager.clearState(myProject);
            }
            FileUtil.createIfDoesntExist(gradleConfigFile);
            try {
              JDOMUtil.writeDocument(document, gradleConfigFile, "\n");
              myModulesConfigurationHash.putAll(affectedConfigurationHash);
            } catch (IOException e) {
              throw new RuntimeException(e);
            }
          }
        });
  }
  // in case of external build this path is returned by
  // FlexCommonUtils.getPathToFlexUnitTempDirectory()
  public static String getPathToFlexUnitTempDirectory(final Project project) {
    final BuildManager buildManager = BuildManager.getInstance();
    final File projectSystemDir = buildManager.getProjectSystemDirectory(project);
    if (projectSystemDir == null) {
      Logger.getInstance(FlexUnitPrecompileTask.class.getName()).error(project);
      return "";
    }

    return FileUtil.toSystemIndependentName(projectSystemDir.getPath()) + "/tmp";
  }
  @Override
  public void apply() throws ConfigurationException {
    commonCompilerArguments.suppressWarnings = generateNoWarningsCheckBox.isSelected();
    compilerSettings.setAdditionalArguments(additionalArgsOptionsField.getText());
    compilerSettings.setScriptTemplates(scriptTemplatesField.getText());
    compilerSettings.setScriptTemplatesClasspath(scriptTemplatesClasspathField.getText());
    compilerSettings.setCopyJsLibraryFiles(copyRuntimeFilesCheckBox.isSelected());
    compilerSettings.setOutputDirectoryForJsLibraryFiles(outputDirectory.getText());

    if (compilerWorkspaceSettings != null) {
      compilerWorkspaceSettings.setPreciseIncrementalEnabled(
          enablePreciseIncrementalCheckBox.isSelected());

      boolean oldEnableDaemon = compilerWorkspaceSettings.getEnableDaemon();
      compilerWorkspaceSettings.setEnableDaemon(keepAliveCheckBox.isSelected());
      if (keepAliveCheckBox.isSelected() != oldEnableDaemon) {
        PluginStartupComponent.getInstance().resetAliveFlag();
      }
    }

    k2jsCompilerArguments.sourceMap = generateSourceMapsCheckBox.isSelected();
    k2jsCompilerArguments.outputPrefix = StringUtil.nullize(outputPrefixFile.getText(), true);
    k2jsCompilerArguments.outputPostfix = StringUtil.nullize(outputPostfixFile.getText(), true);
    k2jsCompilerArguments.moduleKind = getSelectedModuleKind();

    BuildManager.getInstance().clearState(project);
  }
Exemple #4
0
 @Override
 protected void tearDown() throws Exception {
   Messages.setTestDialog(TestDialog.DEFAULT);
   myProjectsManager.projectClosed();
   removeFromLocalRepository("test");
   if (useJps()) {
     CompilerTestUtil.disableExternalCompiler(myProject);
     FileUtil.delete(BuildManager.getInstance().getBuildSystemDirectory());
   }
   super.tearDown();
 }
Exemple #5
0
  private void doCommit(ArtifactModelImpl artifactModel) {
    boolean hasChanges;
    LOG.assertTrue(!myInsideCommit, "Recursive commit");
    myInsideCommit = true;
    try {

      final List<ArtifactImpl> allArtifacts = artifactModel.getOriginalArtifacts();

      final Set<ArtifactImpl> removed = new THashSet<ArtifactImpl>(myModel.myArtifactsList);
      final List<ArtifactImpl> added = new ArrayList<ArtifactImpl>();
      final List<Pair<ArtifactImpl, String>> changed = new ArrayList<Pair<ArtifactImpl, String>>();

      for (ArtifactImpl artifact : allArtifacts) {
        final boolean isAdded = !removed.remove(artifact);
        final ArtifactImpl modifiableCopy = artifactModel.getModifiableCopy(artifact);
        if (isAdded) {
          added.add(artifact);
        } else if (modifiableCopy != null && !modifiableCopy.equals(artifact)) {
          final String oldName = artifact.getName();
          artifact.copyFrom(modifiableCopy);
          changed.add(Pair.create(artifact, oldName));
        }
      }

      myModel.setArtifactsList(allArtifacts);
      myModificationTracker.incModificationCount();
      final ArtifactListener publisher = myProject.getMessageBus().syncPublisher(TOPIC);
      hasChanges = !removed.isEmpty() || !added.isEmpty() || !changed.isEmpty();
      ProjectRootManagerEx.getInstanceEx(myProject)
          .mergeRootsChangesDuring(
              new Runnable() {
                @Override
                public void run() {
                  for (ArtifactImpl artifact : removed) {
                    publisher.artifactRemoved(artifact);
                  }
                  // it's important to send 'removed' events before 'added'. Otherwise when
                  // artifacts are reloaded from xml artifact pointers will be damaged
                  for (ArtifactImpl artifact : added) {
                    publisher.artifactAdded(artifact);
                  }
                  for (Pair<ArtifactImpl, String> pair : changed) {
                    publisher.artifactChanged(pair.getFirst(), pair.getSecond());
                  }
                }
              });
    } finally {
      myInsideCommit = false;
    }
    updateWatchedRoots();
    if (hasChanges) {
      BuildManager.getInstance().clearState(myProject);
    }
  }