Java DetectionExcludesConfiguration类代码示例

import com.intellij.framework.detection.DetectionExcludesConfiguration; //导入依赖的package包/类
private void excludeFrameworkDetection(final Project project, FacetTypeId facetTypeId) {
    final DetectionExcludesConfiguration configuration = DetectionExcludesConfiguration.getInstance(project);
    final FacetType facetType = FacetTypeRegistry.getInstance().findFacetType(facetTypeId);
    final FrameworkType frameworkType = FrameworkDetectionUtil.findFrameworkTypeForFacetDetector(facetType);

    if (frameworkType != null) {
        configuration.addExcludedFramework(frameworkType);
    }
}
 

import com.intellij.framework.detection.DetectionExcludesConfiguration; //导入依赖的package包/类
public void processUncheckedNodes(final DetectionExcludesConfiguration excludesConfiguration) {
  getTree().processUncheckedNodes(new Consumer<DetectedFrameworkTreeNodeBase>() {
    @Override
    public void consume(DetectedFrameworkTreeNodeBase node) {
      node.disableDetection(excludesConfiguration);
    }
  });
}
 

import com.intellij.framework.detection.DetectionExcludesConfiguration; //导入依赖的package包/类
private List<? extends DetectedFrameworkDescription> runDetector(Integer detectorId,
                                                                 FileBasedIndex index,
                                                                 DetectionExcludesConfiguration excludesConfiguration,
                                                                 final boolean processNewFilesOnly) {
  Collection<VirtualFile> acceptedFiles = index.getContainingFiles(FrameworkDetectionIndex.NAME, detectorId, GlobalSearchScope.projectScope(myProject));
  final Collection<VirtualFile> filesToProcess;
  if (processNewFilesOnly) {
    filesToProcess = myDetectedFrameworksData.retainNewFiles(detectorId, acceptedFiles);
  }
  else {
    filesToProcess = new ArrayList<VirtualFile>(acceptedFiles);
  }
  FrameworkDetector detector = FrameworkDetectorRegistry.getInstance().getDetectorById(detectorId);
  if (detector == null) {
    LOG.info("Framework detector not found by id " + detectorId);
    return Collections.emptyList();
  }

  ((DetectionExcludesConfigurationImpl)excludesConfiguration).removeExcluded(filesToProcess, detector.getFrameworkType());
  if (LOG.isDebugEnabled()) {
    LOG.debug("Detector '" + detector.getDetectorId() + "': " + acceptedFiles.size() + " accepted files, " + filesToProcess.size() + " files to process");
  }
  final List<? extends DetectedFrameworkDescription> frameworks;
  if (!filesToProcess.isEmpty()) {
    frameworks = detector.detect(filesToProcess, new FrameworkDetectionContextImpl(myProject));
  }
  else {
    frameworks = Collections.emptyList();
  }
  return frameworks;
}
 

import com.intellij.framework.detection.DetectionExcludesConfiguration; //导入依赖的package包/类
private List<? extends DetectedFrameworkDescription> getValidDetectedFrameworks() {
  final Set<Integer> detectors = myDetectedFrameworksData.getDetectorsForDetectedFrameworks();
  List<DetectedFrameworkDescription> descriptions = new ArrayList<DetectedFrameworkDescription>();
  final FileBasedIndex index = FileBasedIndex.getInstance();
  final DetectionExcludesConfiguration excludesConfiguration = DetectionExcludesConfiguration.getInstance(myProject);
  for (Integer id : detectors) {
    final Collection<? extends DetectedFrameworkDescription> frameworks = runDetector(id, index, excludesConfiguration, false);
    for (DetectedFrameworkDescription framework : frameworks) {
      descriptions.add(framework);
    }
  }
  return FrameworkDetectionUtil.removeDisabled(descriptions);
}
 

import com.intellij.framework.detection.DetectionExcludesConfiguration; //导入依赖的package包/类
private void disableFacetAutodetection(Module module, IdeModifiableModelsProvider provider) {
  final DetectionExcludesConfiguration excludesConfiguration = DetectionExcludesConfiguration.getInstance(module.getProject());
  final FrameworkType frameworkType = FrameworkDetectionUtil.findFrameworkTypeForFacetDetector(myFacetType);
  if (frameworkType != null) {
    for (VirtualFile file : provider.getContentRoots(module)) {
      excludesConfiguration.addExcludedFile(file, frameworkType);
    }
  }
}
 

import com.intellij.framework.detection.DetectionExcludesConfiguration; //导入依赖的package包/类
protected boolean isFacetDetectionDisabled(Project project) {
  final DetectionExcludesConfiguration excludesConfiguration = DetectionExcludesConfiguration.getInstance(project);
  final FrameworkType frameworkType = FrameworkDetectionUtil.findFrameworkTypeForFacetDetector(myFacetType);
  if (frameworkType == null) return false;

  return excludesConfiguration.isExcludedFromDetection(frameworkType);
}
 

import com.intellij.framework.detection.DetectionExcludesConfiguration; //导入依赖的package包/类
private void disableFacetAutodetection(Module module, MavenModifiableModelsProvider provider) {
  final DetectionExcludesConfiguration excludesConfiguration = DetectionExcludesConfiguration.getInstance(module.getProject());
  final FrameworkType frameworkType = FrameworkDetectionUtil.findFrameworkTypeForFacetDetector(myFacetType);
  if (frameworkType != null) {
    for (VirtualFile file : provider.getContentRoots(module)) {
      excludesConfiguration.addExcludedFile(file, frameworkType);
    }
  }
}
 

import com.intellij.framework.detection.DetectionExcludesConfiguration; //导入依赖的package包/类
public FrameworkDetectionConfigurable(@NotNull Project project) {
  myExcludesConfiguration = DetectionExcludesConfiguration.getInstance(project);
  myConfigurable = new DetectionExcludesConfigurable(project, (DetectionExcludesConfigurationImpl)myExcludesConfiguration);
}
 

import com.intellij.framework.detection.DetectionExcludesConfiguration; //导入依赖的package包/类
@Override
public DetectionExcludesConfiguration getEditableObject() {
  return myExcludesConfiguration;
}
 

import com.intellij.framework.detection.DetectionExcludesConfiguration; //导入依赖的package包/类
public void updateProject(@NotNull Project project, @NotNull ModifiableModelsProvider modelsProvider, @NotNull ModulesProvider modulesProvider) {
  FrameworkDetectionUtil.setupFrameworks(myDetectedFrameworksComponent.getSelectedFrameworks(), modelsProvider, modulesProvider);
  myDetectedFrameworksComponent.processUncheckedNodes(DetectionExcludesConfiguration.getInstance(project));
}
 

import com.intellij.framework.detection.DetectionExcludesConfiguration; //导入依赖的package包/类
@Override
public void disableDetection(DetectionExcludesConfiguration configuration) {
  for (VirtualFile file : myDescription.getRelatedFiles()) {
    configuration.addExcludedFile(file, myDescription.getDetector().getFrameworkType());
  }
}
 

import com.intellij.framework.detection.DetectionExcludesConfiguration; //导入依赖的package包/类
@Override
public void disableDetection(DetectionExcludesConfiguration configuration) {
  configuration.addExcludedFramework(myFrameworkType);
}
 

import com.intellij.framework.detection.DetectionExcludesConfiguration; //导入依赖的package包/类
@Override
public void disableDetection(DetectionExcludesConfiguration configuration) {
  configuration.addExcludedFile(myDirectory, null);
}
 

import com.intellij.framework.detection.DetectionExcludesConfiguration; //导入依赖的package包/类
@Override
protected void doOKAction() {
  myComponent.processUncheckedNodes(DetectionExcludesConfiguration.getInstance(myProject));
  super.doOKAction();
}
 

import com.intellij.framework.detection.DetectionExcludesConfiguration; //导入依赖的package包/类
private void doRunDetection() {
  Set<Integer> detectorsToProcess;
  synchronized (myLock) {
    detectorsToProcess = new HashSet<Integer>(myDetectorsToProcess);
    detectorsToProcess.addAll(myDetectorsToProcess);
    myDetectorsToProcess.clear();
  }
  if (detectorsToProcess.isEmpty()) return;

  if (LOG.isDebugEnabled()) {
    LOG.debug("Starting framework detectors: " + detectorsToProcess);
  }
  final FileBasedIndex index = FileBasedIndex.getInstance();
  List<DetectedFrameworkDescription> newDescriptions = new ArrayList<DetectedFrameworkDescription>();
  List<DetectedFrameworkDescription> oldDescriptions = new ArrayList<DetectedFrameworkDescription>();
  final DetectionExcludesConfiguration excludesConfiguration = DetectionExcludesConfiguration.getInstance(myProject);
  for (Integer id : detectorsToProcess) {
    final List<? extends DetectedFrameworkDescription> frameworks = runDetector(id, index, excludesConfiguration, true);
    oldDescriptions.addAll(frameworks);
    final Collection<? extends DetectedFrameworkDescription> updated = myDetectedFrameworksData.updateFrameworksList(id, frameworks);
    newDescriptions.addAll(updated);
    oldDescriptions.removeAll(updated);
    if (LOG.isDebugEnabled()) {
      LOG.debug(frameworks.size() + " frameworks detected, " + updated.size() + " changed");
    }
  }

  Set<String> frameworkNames = new HashSet<String>();
  for (final DetectedFrameworkDescription description : FrameworkDetectionUtil.removeDisabled(newDescriptions, oldDescriptions)) {
    frameworkNames.add(description.getDetector().getFrameworkType().getPresentableName());
  }
  if (!frameworkNames.isEmpty()) {
    String names = StringUtil.join(frameworkNames, ", ");
    final String text = ProjectBundle.message("framework.detected.info.text", names, frameworkNames.size());
    FRAMEWORK_DETECTION_NOTIFICATION
      .createNotification("Frameworks detected", text, NotificationType.INFORMATION, new NotificationListener() {
        @Override
        public void hyperlinkUpdate(@NotNull Notification notification, @NotNull HyperlinkEvent event) {
          if (event.getEventType() == HyperlinkEvent.EventType.ACTIVATED) {
            showSetupFrameworksDialog(notification);
          }
        }
      }).notify(myProject);
  }
}