com.intellij.util.PlatformUtils Java Examples

@Test
public void testJavascriptLanguageAvailableForUltimateEdition() {
  TestUtils.setPlatformPrefix(testDisposable, PlatformUtils.IDEA_PREFIX);
  ProjectViewSet projectViewSet =
      ProjectViewSet.builder()
          .add(
              ProjectView.builder()
                  .add(
                      ScalarSection.builder(WorkspaceTypeSection.KEY)
                          .set(WorkspaceType.JAVASCRIPT))
                  .add(
                      ListSection.builder(AdditionalLanguagesSection.KEY)
                          .add(LanguageClass.JAVASCRIPT))
                  .build())
          .build();
  WorkspaceLanguageSettings workspaceLanguageSettings =
      LanguageSupport.createWorkspaceLanguageSettings(projectViewSet);
  errorCollector.assertNoIssues();
  assertThat(workspaceLanguageSettings)
      .isEqualTo(
          new WorkspaceLanguageSettings(
              WorkspaceType.JAVASCRIPT,
              ImmutableSet.of(LanguageClass.JAVASCRIPT, LanguageClass.GENERIC)));
}
 

@Test
public void testJavascriptWorkspaceTypeUnavailableForCommunityEdition() {
  TestUtils.setPlatformPrefix(testDisposable, PlatformUtils.IDEA_CE_PREFIX);
  ProjectViewSet projectViewSet =
      ProjectViewSet.builder()
          .add(
              ProjectView.builder()
                  .add(
                      ScalarSection.builder(WorkspaceTypeSection.KEY)
                          .set(WorkspaceType.JAVASCRIPT))
                  .build())
          .build();
  WorkspaceLanguageSettings workspaceLanguageSettings =
      LanguageSupport.createWorkspaceLanguageSettings(projectViewSet);
  LanguageSupport.validateLanguageSettings(context, workspaceLanguageSettings);
  errorCollector.assertIssues("Workspace type 'javascript' is not supported by this plugin");
}
 

@Test
public void testTypescriptLanguageAvailableInUltimateEdition() {
  TestUtils.setPlatformPrefix(testDisposable, PlatformUtils.IDEA_PREFIX);
  ProjectViewSet projectViewSet =
      ProjectViewSet.builder()
          .add(
              ProjectView.builder()
                  .add(ScalarSection.builder(WorkspaceTypeSection.KEY).set(WorkspaceType.JAVA))
                  .add(
                      ListSection.builder(AdditionalLanguagesSection.KEY)
                          .add(LanguageClass.TYPESCRIPT))
                  .build())
          .build();
  WorkspaceLanguageSettings workspaceLanguageSettings =
      LanguageSupport.createWorkspaceLanguageSettings(projectViewSet);
  errorCollector.assertNoIssues();
  assertThat(workspaceLanguageSettings)
      .isEqualTo(
          new WorkspaceLanguageSettings(
              WorkspaceType.JAVA,
              ImmutableSet.of(
                  LanguageClass.TYPESCRIPT, LanguageClass.GENERIC, LanguageClass.JAVA)));
}
 

public void initComponent() {
    VERSION = PluginManager.getPlugin(PluginId.getId("com.wakatime.intellij.plugin")).getVersion();
    log.info("Initializing WakaTime plugin v" + VERSION + " (https://wakatime.com/)");
    //System.out.println("Initializing WakaTime plugin v" + VERSION + " (https://wakatime.com/)");

    // Set runtime constants
    IDE_NAME = PlatformUtils.getPlatformPrefix();
    IDE_VERSION = ApplicationInfo.getInstance().getFullVersion();

    setupDebugging();
    setLoggingLevel();
    Dependencies.configureProxy();
    checkApiKey();
    checkCli();
    setupEventListeners();
    setupQueueProcessor();
    checkDebug();
    log.info("Finished initializing WakaTime plugin");
}
 

@Test
public void testTypescriptNotLanguageAvailableInCommunityEdition() {
  TestUtils.setPlatformPrefix(testDisposable, PlatformUtils.IDEA_CE_PREFIX);
  ProjectViewSet projectViewSet =
      ProjectViewSet.builder()
          .add(
              ProjectView.builder()
                  .add(ScalarSection.builder(WorkspaceTypeSection.KEY).set(WorkspaceType.JAVA))
                  .add(
                      ListSection.builder(AdditionalLanguagesSection.KEY)
                          .add(LanguageClass.TYPESCRIPT))
                  .build())
          .build();
  WorkspaceLanguageSettings workspaceLanguageSettings =
      LanguageSupport.createWorkspaceLanguageSettings(projectViewSet);
  LanguageSupport.validateLanguageSettings(context, workspaceLanguageSettings);
  errorCollector.assertIssues("Language 'typescript' is not supported by this plugin");
}
 

public void addSettingsFields(@NotNull SettingsStep settingsStep) {
  settingsStep.addSettingsField(FlutterBundle.message("flutter.module.create.settings.description.label"), descriptionField);
  settingsStep.addSettingsField(FlutterBundle.message("flutter.module.create.settings.type.label"),
                                projectTypeForm.getComponent());
  settingsStep.addSettingsField(FlutterBundle.message("flutter.module.create.settings.radios.org.label"), orgField);
  settingsStep.addSettingsField(FlutterBundle.message("flutter.module.create.settings.radios.android.label"),
                                androidLanguageRadios.getComponent());
  settingsStep.addSettingsField(FlutterBundle.message("flutter.module.create.settings.radios.ios.label"),
                                iosLanguageRadios.getComponent());
  // WebStorm has a smaller area for the wizard UI.
  if (!PlatformUtils.isWebStorm()) {
    settingsStep.addSettingsComponent(new SettingsHelpForm().getComponent());
  }

  settingsStep.addSettingsComponent(createParams.setInitialValues().getComponent());
}
 

/**
 * Return true if the passed module is of a Flutter type. Before version M16 this plugin had its own Flutter {@link ModuleType}.
 * Post M16 a Flutter module is defined by the following:
 * <p>
 * <code>
 * [Flutter support enabled for a module] ===
 * [Dart support enabled && referenced Dart SDK is the one inside a Flutter SDK]
 * </code>
 */
public static boolean isFlutterModule(@Nullable final Module module) {
  if (module == null || module.isDisposed()) return false;

  if (PlatformUtils.isIntelliJ() || FlutterUtils.isAndroidStudio()) {
    // [Flutter support enabled for a module] ===
    //   [Dart support enabled && referenced Dart SDK is the one inside a Flutter SDK]
    final DartSdk dartSdk = DartPlugin.getDartSdk(module.getProject());
    final String dartSdkPath = dartSdk != null ? dartSdk.getHomePath() : null;
    return validDartSdkPath(dartSdkPath) && DartPlugin.isDartSdkEnabled(module);
  }
  else {
    // If not IntelliJ, assume a small IDE (no multi-module project support).
    return declaresFlutter(module);
  }
}
 

void startTabNine() throws IOException {
    if (this.proc != null) {
        this.proc.destroy();
        this.proc = null;
    }
    // When we tell TabNine that it's talking to IntelliJ, it won't suggest language server
    // setup since we assume it's already built into the IDE
    List<String> command = new ArrayList<>();
    command.add(TabNineFinder.getTabNinePath());
    List<String> metadata = new ArrayList<>();
    metadata.add("--client-metadata");
    metadata.add("pluginVersion=" + Utils.getPluginVersion());
    metadata.add("clientIsUltimate=" + PlatformUtils.isIdeaUltimate());
    final ApplicationInfo applicationInfo = ApplicationInfo.getInstance();
    if (applicationInfo != null) {
        command.add("--client");
        command.add(applicationInfo.getVersionName());
        metadata.add("clientVersion=" + applicationInfo.getFullVersion());
        metadata.add("clientApiVersion=" + applicationInfo.getApiVersion());
    }
    command.addAll(metadata);
    ProcessBuilder builder = new ProcessBuilder(command);
    this.proc = builder.start();
    this.procLineReader = new BufferedReader(new InputStreamReader(this.proc.getInputStream(), StandardCharsets.UTF_8));
}
 

public void addSettingsFields(@NotNull SettingsStep settingsStep) {
  settingsStep.addSettingsField(FlutterBundle.message("flutter.module.create.settings.description.label"), descriptionField);
  settingsStep.addSettingsField(FlutterBundle.message("flutter.module.create.settings.type.label"),
                                projectTypeForm.getComponent());
  settingsStep.addSettingsField(FlutterBundle.message("flutter.module.create.settings.radios.org.label"), orgField);
  settingsStep.addSettingsField(FlutterBundle.message("flutter.module.create.settings.radios.android.label"),
                                androidLanguageRadios.getComponent());
  settingsStep.addSettingsField(FlutterBundle.message("flutter.module.create.settings.radios.ios.label"),
                                iosLanguageRadios.getComponent());
  // WebStorm has a smaller area for the wizard UI.
  if (!PlatformUtils.isWebStorm()) {
    settingsStep.addSettingsComponent(new SettingsHelpForm().getComponent());
  }

  settingsStep.addSettingsComponent(createParams.setInitialValues().getComponent());
}
 

/**
 * Return true if the passed module is of a Flutter type. Before version M16 this plugin had its own Flutter {@link ModuleType}.
 * Post M16 a Flutter module is defined by the following:
 * <p>
 * <code>
 * [Flutter support enabled for a module] ===
 * [Dart support enabled && referenced Dart SDK is the one inside a Flutter SDK]
 * </code>
 */
public static boolean isFlutterModule(@Nullable final Module module) {
  if (module == null || module.isDisposed()) return false;

  if (PlatformUtils.isIntelliJ() || FlutterUtils.isAndroidStudio()) {
    // [Flutter support enabled for a module] ===
    //   [Dart support enabled && referenced Dart SDK is the one inside a Flutter SDK]
    final DartSdk dartSdk = DartPlugin.getDartSdk(module.getProject());
    final String dartSdkPath = dartSdk != null ? dartSdk.getHomePath() : null;
    return validDartSdkPath(dartSdkPath) && DartPlugin.isDartSdkEnabled(module);
  }
  else {
    // If not IntelliJ, assume a small IDE (no multi-module project support).
    return declaresFlutter(module);
  }
}
 

@Test
public void testErrorMessageInCommunityEdition() {
  TestUtils.setPlatformPrefix(getTestRootDisposable(), PlatformUtils.IDEA_CE_PREFIX);
  setProjectView(
      "directories:",
      "  common/jslayout",
      "targets:",
      "  //common/jslayout/...:all",
      "workspace_type: javascript");

  workspace.createDirectory(new WorkspacePath("common/jslayout"));

  BlazeSyncParams syncParams =
      BlazeSyncParams.builder()
          .setTitle("Full Sync")
          .setSyncMode(SyncMode.FULL)
          .setSyncOrigin("test")
          .setBlazeBuildParams(BlazeBuildParams.fromProject(getProject()))
          .setAddProjectViewTargets(true)
          .build();
  runBlazeSync(syncParams);
  errorCollector.assertHasErrors();
}
 

/**
 * Sets the platform prefix system property, reverting to the previous value when the supplied
 * parent disposable is disposed.
 */
public static void setPlatformPrefix(Disposable parentDisposable, String platformPrefix) {
  String prevValue = System.getProperty(PlatformUtils.PLATFORM_PREFIX_KEY);
  System.setProperty(PlatformUtils.PLATFORM_PREFIX_KEY, platformPrefix);
  Disposer.register(
      parentDisposable,
      () -> {
        if (prevValue != null) {
          System.setProperty(PlatformUtils.PLATFORM_PREFIX_KEY, prevValue);
        } else {
          System.clearProperty(PlatformUtils.PLATFORM_PREFIX_KEY);
        }
      });
}
 

@Test
public void testTestSourcesMissingFromDirectoriesSectionAreAdded() {
  TestUtils.setPlatformPrefix(getTestRootDisposable(), PlatformUtils.IDEA_PREFIX);
  setProjectView(
      "directories:",
      "  common/jslayout",
      "targets:",
      "  //common/jslayout/...:all",
      "test_sources:",
      "  */tests",
      "workspace_type: javascript");

  VirtualFile testDir = workspace.createDirectory(new WorkspacePath("common/jslayout/tests"));

  BlazeSyncParams syncParams =
      BlazeSyncParams.builder()
          .setTitle("Full Sync")
          .setSyncMode(SyncMode.FULL)
          .setSyncOrigin("test")
          .setBlazeBuildParams(BlazeBuildParams.fromProject(getProject()))
          .setAddProjectViewTargets(true)
          .build();
  runBlazeSync(syncParams);

  errorCollector.assertNoIssues();

  ImmutableList<ContentEntry> contentEntries = getWorkspaceContentEntries();
  assertThat(contentEntries).hasSize(1);

  SourceFolder root = findSourceFolder(contentEntries.get(0), testDir.getParent());
  assertThat(root.isTestSource()).isFalse();

  SourceFolder testRoot = findSourceFolder(contentEntries.get(0), testDir);
  assertThat(testRoot).isNotNull();
  assertThat(testRoot.isTestSource()).isTrue();
}
 

@Test
public void testPrefetchedExtensions() {
  if (PlatformUtils.isIdeaUltimate()) {
    assertThat(PrefetchFileSource.getAllPrefetchFileExtensions())
        .containsExactly("java", "proto", "dart", "js", "html", "css", "gss", "ts", "tsx");
  } else {
    assertThat(PrefetchFileSource.getAllPrefetchFileExtensions())
        .containsExactly("java", "proto", "dart");
  }
}
 

@Override
public void initComponent() {
  Topics.subscribe(
      AppLifecycleListener.TOPIC,
      /* disposable= */ null,
      new AppLifecycleListener() {
        @Override
        public void appStarting(@Nullable Project projectFromCommandLine) {
          if (PlatformUtils.isIntelliJ() && !PluginUtils.isPluginEnabled(JUNIT_PLUGIN_ID)) {
            notifyJUnitNotEnabled();
          }
        }
      });
}
 

@VisibleForTesting
public static String getToolTagFlag() {
  String platformPrefix = PlatformUtils.getPlatformPrefix();

  // IDEA Community Edition is "Idea", whereas IDEA Ultimate Edition is "idea".
  // That's dumb. Let's make them more useful.
  if (PlatformUtils.isIdeaCommunity()) {
    platformPrefix = "IDEA:community";
  } else if (PlatformUtils.isIdeaUltimate()) {
    platformPrefix = "IDEA:ultimate";
  }
  return TOOL_TAG + platformPrefix;
}
 

private static String getProductId() {
  String platformPrefix = PlatformUtils.getPlatformPrefix();

  // IDEA Community Edition is "Idea", whereas IDEA Ultimate Edition is "idea". Let's make them
  // more useful.
  if (PlatformUtils.isIdeaCommunity()) {
    platformPrefix = "IdeaCommunity";
  } else if (PlatformUtils.isIdeaUltimate()) {
    platformPrefix = "IdeaUltimate";
  }
  return platformPrefix;
}
 

@Nullable
@Override
public WorkspaceType getDefaultWorkspaceType() {
  return PlatformUtils.isGoIde() ? WorkspaceType.GO : null;
}
 

public boolean matchesCurrent() {
  ApplicationInfo appInfo = ApplicationInfo.getInstance();
  return PlatformUtils.getPlatformPrefix().equals(prefix)
      && matchesVersion(majorVersion, appInfo.getMajorVersion())
      && matchesVersion(minorVersion, appInfo.getMinorVersion());
}
 

private static boolean goWorkspaceTypeSupported() {
  return PlatformUtils.isGoIde();
}
 

/** Go plugin is only supported in IJ UE and GoLand. */
private static boolean isGoPluginSupported() {
  return PlatformUtils.isGoIde()
      || PlatformUtils.isIdeaUltimate()
      || ApplicationManager.getApplication().isUnitTestMode();
}
 

@Test
public void testTestSourceChildrenAreNotAddedAsSourceFolders() {
  TestUtils.setPlatformPrefix(getTestRootDisposable(), PlatformUtils.IDEA_PREFIX);
  // child directories of test sources are always test sources, so they should never
  // appear as separate SourceFolders.
  setProjectView(
      "directories:",
      "  common/jslayout",
      "targets:",
      "  //common/jslayout/...:all",
      "test_sources:",
      "  */tests/*",
      "workspace_type: javascript");

  VirtualFile rootDir = workspace.createDirectory(new WorkspacePath("common/jslayout"));
  VirtualFile nestedTestDir =
      workspace.createDirectory(new WorkspacePath("common/jslayout/tests/foo"));

  BlazeSyncParams syncParams =
      BlazeSyncParams.builder()
          .setTitle("Full Sync")
          .setSyncMode(SyncMode.FULL)
          .setSyncOrigin("test")
          .setBlazeBuildParams(BlazeBuildParams.fromProject(getProject()))
          .setAddProjectViewTargets(true)
          .build();
  runBlazeSync(syncParams);

  errorCollector.assertNoIssues();

  ImmutableList<ContentEntry> contentEntries = getWorkspaceContentEntries();
  assertThat(contentEntries).hasSize(1);

  SourceFolder root = findSourceFolder(contentEntries.get(0), rootDir);
  assertThat(root.isTestSource()).isFalse();

  SourceFolder child = findSourceFolder(contentEntries.get(0), nestedTestDir);
  assertThat(child).isNull();

  SourceFolder testRoot = findSourceFolder(contentEntries.get(0), nestedTestDir.getParent());
  assertThat(testRoot).isNotNull();
  assertThat(testRoot.isTestSource()).isTrue();
}
 

@Override
public ImmutableList<WorkspaceType> getSupportedWorkspaceTypes() {
  return PlatformUtils.isGoIde() ? ImmutableList.of(WorkspaceType.GO) : ImmutableList.of();
}
 

/** Sets up the necessary system properties for running IntelliJ tests via blaze/bazel. */
private static void configureSystemProperties() throws IOException {
  File sandbox = new File(TestUtils.getTmpDirFile(), "_intellij_test_sandbox");

  setSandboxPath("idea.home.path", new File(sandbox, "home"));
  setSandboxPath("idea.config.path", new File(sandbox, "config"));
  setSandboxPath("idea.system.path", new File(sandbox, "system"));

  setSandboxPath("java.util.prefs.userRoot", new File(sandbox, "userRoot"));
  setSandboxPath("java.util.prefs.systemRoot", new File(sandbox, "systemRoot"));

  setIfEmpty("idea.classpath.index.enabled", "false");

  // Some plugins have a since-build and until-build restriction, so we need
  // to update the build number here
  String buildNumber = readApiVersionNumber();
  if (buildNumber == null) {
    buildNumber = BuildNumber.currentVersion().asString();
  }
  setIfEmpty("idea.plugins.compatible.build", buildNumber);
  setIfEmpty(PlatformUtils.PLATFORM_PREFIX_KEY, determinePlatformPrefix(buildNumber));

  // Tests fail if they access files outside of the project roots and other system directories.
  // Ensure runfiles and platform api are whitelisted.
  VfsRootAccess.allowRootAccess(RUNFILES_PATH);
  String platformApi = getPlatformApiPath();
  if (platformApi != null) {
    VfsRootAccess.allowRootAccess(platformApi);
  }

  List<String> pluginJars = Lists.newArrayList();
  try {
    Enumeration<URL> urls =
        BlazeTestSystemPropertiesRule.class.getClassLoader().getResources("META-INF/plugin.xml");
    while (urls.hasMoreElements()) {
      URL url = urls.nextElement();
      addArchiveFile(url, pluginJars);
    }
  } catch (IOException e) {
    System.err.println("Cannot find plugin.xml resources");
    e.printStackTrace();
  }

  setIfEmpty("idea.plugins.path", Joiner.on(File.pathSeparator).join(pluginJars));
}
 

@Test
public void testSimpleTestSourcesIdentified() {
  TestUtils.setPlatformPrefix(getTestRootDisposable(), PlatformUtils.IDEA_PREFIX);
  setProjectView(
      "directories:",
      "  common/jslayout/calendar",
      "  common/jslayout/tests",
      "targets:",
      "  //common/jslayout/...:all",
      "test_sources:",
      "  common/jslayout/tests",
      "workspace_type: javascript");

  VirtualFile rootFile = workspace.createDirectory(new WorkspacePath("common/jslayout/calendar"));

  VirtualFile testFile =
      workspace.createFile(new WorkspacePath("common/jslayout/tests/date_formatter_test.js"));

  BlazeSyncParams syncParams =
      BlazeSyncParams.builder()
          .setTitle("Full Sync")
          .setSyncMode(SyncMode.FULL)
          .setSyncOrigin("test")
          .setBlazeBuildParams(BlazeBuildParams.fromProject(getProject()))
          .setAddProjectViewTargets(true)
          .build();
  runBlazeSync(syncParams);

  errorCollector.assertNoIssues();

  assertThat(getWorkspaceContentEntries()).hasSize(2);

  ContentEntry sourceEntry = findContentEntry(rootFile);
  assertThat(sourceEntry.getSourceFolders()).hasLength(1);

  SourceFolder nonTestSource = findSourceFolder(sourceEntry, rootFile);
  assertThat(nonTestSource.isTestSource()).isFalse();

  ContentEntry testEntry = findContentEntry(testFile.getParent());
  assertThat(testEntry.getSourceFolders()).hasLength(1);

  SourceFolder testSource = findSourceFolder(testEntry, testFile.getParent());
  assertThat(testSource.isTestSource()).isTrue();
}
 

public boolean isPrimaryGenerator() {
    return PlatformUtils.isPhpStorm();
}
 

public BaseFunctionalTestCase() {
    System.setProperty(PlatformUtils.PLATFORM_PREFIX_KEY, PlatformUtils.IDEA_CE_PREFIX);
}
 

protected BaseGuiTest() {
    System.setProperty(PlatformUtils.PLATFORM_PREFIX_KEY, PlatformUtils.PYCHARM_PREFIX);
}
 

public boolean isPrimaryGenerator()
{
    return PlatformUtils.isPhpStorm();
}
 

static boolean allowJarCache() {
  return !SystemInfo.isMac
      || BuildSystemProvider.defaultBuildSystem().buildSystem() == BuildSystem.Bazel
      || "AndroidStudio".equals(PlatformUtils.getPlatformPrefix());
}