From a267474e63f23452a3b489b8dd7028054d8b7a30 Mon Sep 17 00:00:00 2001
From: Bela VanderVoort <twobitbela@gmail.com>
Date: Sun, 23 Jan 2022 12:30:03 -0600
Subject: [PATCH] Updates to the rider plugin

Use DOTNET_NOLOGO - fixes #533 and #549
Use a custom tools path to allow csharpier to be updated/installed while running - fixes #563 and #531
Use the solution version of csharpier - fixes #493
---
 Docs/ExtensionTestCases.md                    |  20 ++
 .../.run/Run IDE with Plugin.run.xml          |   5 +
 .../intellij/csharpier/CSharpierLogger.java   |  22 ++
 .../CSharpierProcessPipeMultipleFiles.java    |  10 +-
 .../csharpier/CSharpierProcessProvider.java   | 216 ++++++++++++++++++
 .../csharpier/CSharpierProcessSingleFile.java |  12 +-
 .../intellij/csharpier/CSharpierService.java  | 102 ---------
 .../intellij/csharpier/CSharpierStartup.java  |   2 +-
 .../csharpier/CustomPathInstaller.java        |  37 +++
 .../intellij/csharpier/FormattingService.java |  17 +-
 .../intellij/csharpier/ICSharpierProcess.java |   1 +
 .../intellij/csharpier/IProcessKiller.java    |   5 +
 .../csharpier/InstallGlobalAction.java        |  29 +++
 .../csharpier/InstallLocalAction.java         |  44 ++++
 .../intellij/csharpier/InstallerService.java  |  52 +++++
 .../csharpier/NullCSharpierProcess.java       |   5 +
 .../com/intellij/csharpier/ProcessHelper.java |  49 ++++
 .../ReformatWithCSharpierAction.java          |   2 +-
 .../ReformatWithCSharpierOnSave.java          |   2 +-
 .../src/main/resources/META-INF/plugin.xml    |   3 +-
 .../src/CSharpierProcessProvider.ts           |   4 +-
 .../src/CSharpierProcessSingleFile.ts         |   4 +-
 Src/CSharpier.VSCode/src/FormattingService.ts |   4 +-
 23 files changed, 523 insertions(+), 124 deletions(-)
 create mode 100644 Docs/ExtensionTestCases.md
 create mode 100644 Src/CSharpier.Rider/src/main/java/com/intellij/csharpier/CSharpierLogger.java
 create mode 100644 Src/CSharpier.Rider/src/main/java/com/intellij/csharpier/CSharpierProcessProvider.java
 delete mode 100644 Src/CSharpier.Rider/src/main/java/com/intellij/csharpier/CSharpierService.java
 create mode 100644 Src/CSharpier.Rider/src/main/java/com/intellij/csharpier/CustomPathInstaller.java
 create mode 100644 Src/CSharpier.Rider/src/main/java/com/intellij/csharpier/IProcessKiller.java
 create mode 100644 Src/CSharpier.Rider/src/main/java/com/intellij/csharpier/InstallGlobalAction.java
 create mode 100644 Src/CSharpier.Rider/src/main/java/com/intellij/csharpier/InstallLocalAction.java
 create mode 100644 Src/CSharpier.Rider/src/main/java/com/intellij/csharpier/InstallerService.java
 create mode 100644 Src/CSharpier.Rider/src/main/java/com/intellij/csharpier/ProcessHelper.java

diff --git a/Docs/ExtensionTestCases.md b/Docs/ExtensionTestCases.md
new file mode 100644
index 000000000..0159c9e9f
--- /dev/null
+++ b/Docs/ExtensionTestCases.md
@@ -0,0 +1,20 @@
+No installs at all
+- show message to install globaly or in solution
+
+Install globaly
+- should format after
+- can uninstall globaly after process running
+
+Install solution
+- works with existing config
+- works with no config
+- should format after
+
+Formatting
+- Existing open documents get warmed
+- Edit warms
+- Uses correct version - adding lines is easy to test, 0.12 vs 0.14
+
+Action
+- is not shown on files that aren't c#
+- run on save works
\ No newline at end of file
diff --git a/Src/CSharpier.Rider/.run/Run IDE with Plugin.run.xml b/Src/CSharpier.Rider/.run/Run IDE with Plugin.run.xml
index d15ff681a..d5c075663 100644
--- a/Src/CSharpier.Rider/.run/Run IDE with Plugin.run.xml	
+++ b/Src/CSharpier.Rider/.run/Run IDE with Plugin.run.xml	
@@ -2,6 +2,11 @@
   <configuration default="false" name="Run Plugin" type="GradleRunConfiguration" factoryName="Gradle">
     <log_file alias="idea.log" path="$PROJECT_DIR$/build/idea-sandbox/system/log/idea.log" />
     <ExternalSystemSettings>
+      <option name="env">
+        <map>
+          <entry key="DEBUG" value="1" />
+        </map>
+      </option>
       <option name="executionName" />
       <option name="externalProjectPath" value="$PROJECT_DIR$" />
       <option name="externalSystemIdString" value="GRADLE" />
diff --git a/Src/CSharpier.Rider/src/main/java/com/intellij/csharpier/CSharpierLogger.java b/Src/CSharpier.Rider/src/main/java/com/intellij/csharpier/CSharpierLogger.java
new file mode 100644
index 000000000..03bbcb961
--- /dev/null
+++ b/Src/CSharpier.Rider/src/main/java/com/intellij/csharpier/CSharpierLogger.java
@@ -0,0 +1,22 @@
+package com.intellij.csharpier;
+
+import com.intellij.openapi.diagnostic.Logger;
+import org.apache.log4j.Level;
+
+public class CSharpierLogger {
+    private final static Logger logger = createLogger();
+
+    private static Logger createLogger() {
+        Logger logger = Logger.getInstance(CSharpierLogger.class);
+        if ("1".equals(System.getenv("DEBUG"))) {
+            logger.setLevel(Level.DEBUG);
+        }
+
+        return logger;
+    }
+
+    public static Logger getInstance() {
+        return logger;
+    }
+}
+
diff --git a/Src/CSharpier.Rider/src/main/java/com/intellij/csharpier/CSharpierProcessPipeMultipleFiles.java b/Src/CSharpier.Rider/src/main/java/com/intellij/csharpier/CSharpierProcessPipeMultipleFiles.java
index 7752a9ef3..0e20fd2d6 100644
--- a/Src/CSharpier.Rider/src/main/java/com/intellij/csharpier/CSharpierProcessPipeMultipleFiles.java
+++ b/Src/CSharpier.Rider/src/main/java/com/intellij/csharpier/CSharpierProcessPipeMultipleFiles.java
@@ -10,7 +10,7 @@
 import java.util.concurrent.atomic.AtomicBoolean;
 
 public class CSharpierProcessPipeMultipleFiles implements ICSharpierProcess, Disposable {
-    Logger logger = Logger.getInstance(CSharpierProcessPipeMultipleFiles.class);
+    Logger logger = CSharpierLogger.getInstance();
     String csharpierPath;
 
     Process process = null;
@@ -21,8 +21,9 @@ public class CSharpierProcessPipeMultipleFiles implements ICSharpierProcess, Dis
     public CSharpierProcessPipeMultipleFiles(String csharpierPath, boolean useUtf8) {
         this.csharpierPath = csharpierPath;
         try {
-            this.process = new ProcessBuilder("dotnet", csharpierPath, "--pipe-multiple-files")
-                    .start();
+            ProcessBuilder processBuilder = new ProcessBuilder(csharpierPath, "--pipe-multiple-files");
+            processBuilder.environment().put("DOTNET_NOLOGO", "1");
+            this.process = processBuilder.start();
 
             String charset = useUtf8 ? "utf-8" : Charset.defaultCharset().toString();
 
@@ -33,6 +34,9 @@ public CSharpierProcessPipeMultipleFiles(String csharpierPath, boolean useUtf8)
             this.logger.error("error", e);
         }
 
+        this.logger.debug("Warm CSharpier with initial format");
+        // warm by formatting a file twice, the 3rd time is when it gets really fast
+        this.formatFile("public class ClassName { }", "Test.cs");
         this.formatFile("public class ClassName { }", "Test.cs");
     }
 
diff --git a/Src/CSharpier.Rider/src/main/java/com/intellij/csharpier/CSharpierProcessProvider.java b/Src/CSharpier.Rider/src/main/java/com/intellij/csharpier/CSharpierProcessProvider.java
new file mode 100644
index 000000000..92b25744d
--- /dev/null
+++ b/Src/CSharpier.Rider/src/main/java/com/intellij/csharpier/CSharpierProcessProvider.java
@@ -0,0 +1,216 @@
+package com.intellij.csharpier;
+
+import com.google.gson.Gson;
+import com.google.gson.JsonObject;
+import com.intellij.notification.NotificationGroupManager;
+import com.intellij.notification.NotificationType;
+import com.intellij.openapi.Disposable;
+import com.intellij.openapi.diagnostic.Logger;
+import com.intellij.openapi.editor.Document;
+import com.intellij.openapi.editor.EditorFactory;
+import com.intellij.openapi.editor.event.DocumentEvent;
+import com.intellij.openapi.editor.event.DocumentListener;
+import com.intellij.openapi.fileEditor.FileDocumentManager;
+import com.intellij.openapi.fileEditor.FileEditor;
+import com.intellij.openapi.fileEditor.FileEditorManager;
+import com.intellij.openapi.project.Project;
+import com.intellij.openapi.vfs.VirtualFile;
+import org.apache.maven.artifact.versioning.ComparableVersion;
+import org.jetbrains.annotations.NotNull;
+
+import java.io.File;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.HashMap;
+import java.util.Map;
+
+public class CSharpierProcessProvider implements DocumentListener, @NotNull Disposable, IProcessKiller {
+    private final CustomPathInstaller customPathInstaller = new CustomPathInstaller();
+    private final Logger logger = CSharpierLogger.getInstance();
+    private final Project project;
+
+    private boolean warnedForOldVersion;
+    private final HashMap<String, Boolean> warmingByDirectory = new HashMap<>();
+    private final HashMap<String, String> csharpierVersionByDirectory = new HashMap<>();
+    private final HashMap<String, ICSharpierProcess> csharpierProcessesByVersion = new HashMap<>();
+
+    public CSharpierProcessProvider(@NotNull Project project) {
+        this.project = project;
+
+        for (FileEditor fileEditor : FileEditorManager.getInstance(project).getAllEditors()) {
+            this.findAndWarmProcess(fileEditor.getFile().getPath());
+        }
+
+        EditorFactory.getInstance().getEventMulticaster().addDocumentListener(this, this);
+    }
+
+    @Override
+    public void documentChanged(@NotNull DocumentEvent event) {
+        Document document = event.getDocument();
+        VirtualFile file = FileDocumentManager.getInstance().getFile(document);
+
+        if (file == null
+                || file.getExtension() == null
+                || !file.getExtension().equalsIgnoreCase("cs")
+        ) {
+            return;
+        }
+        String filePath = file.getPath();
+        this.findAndWarmProcess(filePath);
+    }
+
+    @NotNull
+    static CSharpierProcessProvider getInstance(@NotNull Project project) {
+        return project.getService(CSharpierProcessProvider.class);
+    }
+
+    private void findAndWarmProcess(String filePath) {
+        String directory = Path.of(filePath).getParent().toString();
+        if (this.warmingByDirectory.getOrDefault(directory, false)) {
+            return;
+        }
+        this.logger.debug("Ensure there is a csharpier process for " + directory);
+        this.warmingByDirectory.put(directory, true);
+        String version = this.csharpierVersionByDirectory.getOrDefault(directory, null);
+        if (version == null) {
+            version = this.getCSharpierVersion(directory);
+            if (version == null || version.isEmpty()) {
+                InstallerService.getInstance(this.project).displayInstallNeededMessage(directory, this);
+            }
+            this.csharpierVersionByDirectory.put(directory, version);
+        }
+
+        if (!this.csharpierProcessesByVersion.containsKey(version)) {
+            this.csharpierProcessesByVersion.put(version, this.setupCSharpierProcess(
+                    directory,
+                    version
+            ));
+        }
+
+        this.warmingByDirectory.remove(directory);
+    }
+
+    public ICSharpierProcess getProcessFor(String filePath) {
+        String directory = Path.of(filePath).getParent().toString();
+        String version = this.csharpierVersionByDirectory.getOrDefault(directory, null);
+        if (version == null) {
+            this.findAndWarmProcess(filePath);
+            version = this.csharpierVersionByDirectory.get(directory);
+        }
+
+        if (version == null || !this.csharpierProcessesByVersion.containsKey(version)) {
+            // this shouldn't really happen, but just in case
+            return new NullCSharpierProcess();
+        }
+
+        return this.csharpierProcessesByVersion.get(version);
+    }
+
+    ;
+
+    private String getCSharpierVersion(String directoryThatContainsFile) {
+        Path currentDirectory = Path.of(directoryThatContainsFile);
+        try {
+            while (true) {
+                Path configPath = Path.of(currentDirectory.toString(), ".config/dotnet-tools.json");
+                String dotnetToolsPath = configPath.toString();
+                File file = new File(dotnetToolsPath);
+                this.logger.debug("Looking for " + dotnetToolsPath);
+                if (file.exists()) {
+                    String data = new String(Files.readAllBytes(configPath));
+                    JsonObject configData = new Gson().fromJson(data, JsonObject.class);
+                    JsonObject tools = configData.getAsJsonObject("tools");
+                    if (tools != null) {
+                        JsonObject csharpier = tools.getAsJsonObject("csharpier");
+                        if (csharpier != null) {
+                            String version = csharpier.get("version").getAsString();
+                            if (version != null) {
+                                this.logger.debug("Found version " + version + " in " + dotnetToolsPath);
+                                return version;
+                            }
+                        }
+                    }
+                }
+
+                if (currentDirectory.getParent() == null) {
+                    break;
+                }
+                currentDirectory = currentDirectory.getParent();
+            }
+        } catch (Exception ex) {
+            this.logger.error(ex);
+        }
+
+        this.logger.debug(
+                "Unable to find dotnet-tools.json, falling back to running dotnet csharpier --version"
+        );
+
+        Map<String, String> env = new HashMap<>();
+        env.put("DOTNET_NOLOGO", "1");
+
+        String[] command = {"dotnet", "csharpier", "--version"};
+
+        String version = ProcessHelper.ExecuteCommand(command, env, new File(directoryThatContainsFile));
+
+        this.logger.debug("dotnet csharpier --version output: " + version);
+
+        return version == null ? "" : version;
+    }
+
+
+    private ICSharpierProcess setupCSharpierProcess(String directory, String version) {
+        if (version == null || version.equals("")) {
+            return new NullCSharpierProcess();
+        }
+
+        this.customPathInstaller.ensureVersionInstalled(version);
+        String customPath = this.customPathInstaller.getPathForVersion(version);
+        try {
+            this.logger.debug("Adding new version " + version + " process for " + directory);
+
+            ComparableVersion installedVersion = new ComparableVersion(version);
+            ComparableVersion pipeFilesVersion = new ComparableVersion("0.12.0");
+            ComparableVersion utf8Version = new ComparableVersion("0.14.0");
+
+            if (installedVersion.compareTo(pipeFilesVersion) < 0) {
+                if (!this.warnedForOldVersion) {
+                    String content = "Please upgrade to CSharpier >= 0.12.0 for bug fixes and improved formatting speed.";
+                    NotificationGroupManager.getInstance().getNotificationGroup("CSharpier")
+                            .createNotification(content, NotificationType.INFORMATION)
+                            .notify(this.project);
+
+                    this.warnedForOldVersion = true;
+                }
+
+
+                return new CSharpierProcessSingleFile(customPath);
+            }
+
+            boolean useUtf8 = installedVersion.compareTo(utf8Version) >= 0;
+
+            return new CSharpierProcessPipeMultipleFiles(customPath, useUtf8);
+
+        } catch (Exception ex) {
+            this.logger.error(ex);
+        }
+
+        return new NullCSharpierProcess();
+    }
+
+    @Override
+    public void dispose() {
+        this.killRunningProcesses();
+    }
+
+    public void killRunningProcesses() {
+        for (String key : this.csharpierProcessesByVersion.keySet()) {
+            this.logger.debug(
+                    "disposing of process for version " + (key == "" ? "null" : key)
+            );
+            this.csharpierProcessesByVersion.get(key).dispose();
+        }
+        this.warmingByDirectory.clear();
+        this.csharpierVersionByDirectory.clear();
+        this.csharpierProcessesByVersion.clear();
+    }
+}
diff --git a/Src/CSharpier.Rider/src/main/java/com/intellij/csharpier/CSharpierProcessSingleFile.java b/Src/CSharpier.Rider/src/main/java/com/intellij/csharpier/CSharpierProcessSingleFile.java
index 8d380e117..853c392c3 100644
--- a/Src/CSharpier.Rider/src/main/java/com/intellij/csharpier/CSharpierProcessSingleFile.java
+++ b/Src/CSharpier.Rider/src/main/java/com/intellij/csharpier/CSharpierProcessSingleFile.java
@@ -8,7 +8,7 @@
 import java.io.OutputStream;
 
 public class CSharpierProcessSingleFile implements ICSharpierProcess {
-    Logger logger = Logger.getInstance(CSharpierProcessSingleFile.class);
+    Logger logger = CSharpierLogger.getInstance();
     String csharpierPath;
 
     public CSharpierProcessSingleFile(String csharpierPath) {
@@ -18,7 +18,9 @@ public CSharpierProcessSingleFile(String csharpierPath) {
     @Override
     public String formatFile(String content, String fileName) {
         try {
-            ProcessBuilder processBuilder = new ProcessBuilder("dotnet", this.csharpierPath, "--write-stdout");
+            this.logger.debug("Running " + this.csharpierPath + " --write-stdout");
+            ProcessBuilder processBuilder = new ProcessBuilder(this.csharpierPath, "--write-stdout");
+            processBuilder.environment().put("DOTNET_NOLOGO", "1");
             processBuilder.redirectErrorStream(true);
             Process process = processBuilder.start();
 
@@ -32,7 +34,6 @@ public String formatFile(String content, String fileName) {
 
             var nextCharacter = stdOut.read();
             while (nextCharacter != -1) {
-                this.logger.info("Got Output " + nextCharacter);
                 output.append((char)nextCharacter);
                 nextCharacter = stdOut.read();
             }
@@ -51,4 +52,9 @@ public String formatFile(String content, String fileName) {
 
         return "";
     }
+
+    @Override
+    public void dispose() {
+
+    }
 }
diff --git a/Src/CSharpier.Rider/src/main/java/com/intellij/csharpier/CSharpierService.java b/Src/CSharpier.Rider/src/main/java/com/intellij/csharpier/CSharpierService.java
deleted file mode 100644
index c54431c36..000000000
--- a/Src/CSharpier.Rider/src/main/java/com/intellij/csharpier/CSharpierService.java
+++ /dev/null
@@ -1,102 +0,0 @@
-package com.intellij.csharpier;
-
-import com.esotericsoftware.minlog.Log;
-import com.intellij.notification.Notification;
-import com.intellij.notification.NotificationGroupManager;
-import com.intellij.notification.NotificationType;
-import com.intellij.openapi.diagnostic.Logger;
-import com.intellij.openapi.project.Project;
-import org.apache.maven.artifact.versioning.ComparableVersion;
-import org.jetbrains.annotations.NotNull;
-
-import java.io.IOException;
-import java.io.InputStream;
-import java.util.Scanner;
-
-public class CSharpierService {
-    Logger logger = Logger.getInstance(ReformatWithCSharpierAction.class);
-    String csharpierPath;
-    ICSharpierProcess csharpierProcess;
-    Project project;
-
-    public CSharpierService(@NotNull Project project) {
-        this.project = project;
-        this.csharpierPath = getCSharpierPath();
-
-        this.logger.info("Using command dotnet " + this.csharpierPath);
-
-        this.csharpierProcess = setupCSharpierProcess();
-    }
-
-    public String getCSharpierPath() {
-        // TODO make this some kind of build property so it only works when testing the plugin
-        // or maybe make it a setting?
-        // return "C:\\projects\\csharpier\\Src\\CSharpier.Cli\\bin\\Debug\\net6.0\\dotnet-csharpier.dll";
-
-        return "csharpier";
-    }
-
-    @NotNull
-    static CSharpierService getInstance(@NotNull Project project) {
-        return project.getService(CSharpierService.class);
-    }
-
-    public String execCmd(String cmd) {
-        String result = null;
-        try (InputStream inputStream = Runtime.getRuntime().exec(cmd).getInputStream();
-             Scanner s = new Scanner(inputStream).useDelimiter("\\A")
-        ) {
-            result = s.hasNext() ? s.next() : null;
-        } catch (IOException e) {
-            Log.error(e.getMessage());
-            e.printStackTrace();
-        }
-        return result;
-    }
-
-    private ICSharpierProcess setupCSharpierProcess() {
-        try {
-            String version = execCmd("dotnet " + this.csharpierPath + " --version");
-            this.logger.info("CSharpier version: " + version);
-            if (version == null) {
-                this.displayInstallNeededMessage();
-            }
-            else {
-                ComparableVersion installedVersion = new ComparableVersion(version);
-                ComparableVersion pipeFilesVersion = new ComparableVersion("0.12.0");
-                ComparableVersion utf8Version = new ComparableVersion("0.14.0");
-                if (installedVersion.compareTo(pipeFilesVersion) < 0) {
-                    String content = "Please upgrade to CSharpier >= 0.12.0 for bug fixes and improved formatting speed.";
-                    NotificationGroupManager.getInstance().getNotificationGroup("CSharpier")
-                            .createNotification(content, NotificationType.INFORMATION)
-                            .notify(this.project);
-
-                    return new CSharpierProcessSingleFile(this.csharpierPath);
-                }
-
-                boolean useUtf8 = installedVersion.compareTo(utf8Version) >= 0;
-
-                return new CSharpierProcessPipeMultipleFiles(this.csharpierPath, useUtf8);
-
-            }
-        } catch (Exception ex) {
-            this.logger.error(ex);
-        }
-
-        return new NullCSharpierProcess();
-    }
-
-    private void displayInstallNeededMessage() {
-        Notification notification = NotificationGroupManager.getInstance().getNotificationGroup("CSharpier")
-                .createNotification("CSharpier must be installed globally to support formatting.", NotificationType.WARNING);
-
-        // TODO why can't an action be displayed in this???
-//        notification.addAction(new EditAction());
-
-        notification.notify(this.project);
-    }
-
-    public String format(@NotNull String content, @NotNull String filePath) {
-        return this.csharpierProcess.formatFile(content, filePath);
-    }
-}
diff --git a/Src/CSharpier.Rider/src/main/java/com/intellij/csharpier/CSharpierStartup.java b/Src/CSharpier.Rider/src/main/java/com/intellij/csharpier/CSharpierStartup.java
index 15978d54f..cea4886c8 100644
--- a/Src/CSharpier.Rider/src/main/java/com/intellij/csharpier/CSharpierStartup.java
+++ b/Src/CSharpier.Rider/src/main/java/com/intellij/csharpier/CSharpierStartup.java
@@ -8,6 +8,6 @@
 public class CSharpierStartup implements StartupActivity, DumbAware {
     @Override
     public void runActivity(@NotNull Project project) {
-        CSharpierService.getInstance(project);
+        CSharpierProcessProvider.getInstance(project);
     }
 }
diff --git a/Src/CSharpier.Rider/src/main/java/com/intellij/csharpier/CustomPathInstaller.java b/Src/CSharpier.Rider/src/main/java/com/intellij/csharpier/CustomPathInstaller.java
new file mode 100644
index 000000000..7b95115f1
--- /dev/null
+++ b/Src/CSharpier.Rider/src/main/java/com/intellij/csharpier/CustomPathInstaller.java
@@ -0,0 +1,37 @@
+package com.intellij.csharpier;
+
+import com.intellij.openapi.diagnostic.Logger;
+
+import java.io.File;
+import java.nio.file.Path;
+
+public class CustomPathInstaller {
+    Logger logger = CSharpierLogger.getInstance();
+
+    public void ensureVersionInstalled(String version) {
+        if (version == null || version.equals("")) {
+            return;
+        }
+        String directoryForVersion = getDirectoryForVersion(version);
+        File file = new File(directoryForVersion);
+        if (file.exists()) {
+            this.logger.debug("File at " + directoryForVersion + " already exists");
+            return;
+        }
+
+        String[] command = {"dotnet", "tool", "install", "csharpier", "--version", version, "--tool-path", directoryForVersion};
+        ProcessHelper.ExecuteCommand(command, null, null);
+    }
+
+    private String getDirectoryForVersion(String version) {
+        String userHome = System.getProperty("user.home");
+        Path path = Path.of(userHome, ".csharpier", version);
+        return path.toString();
+    }
+
+    public String getPathForVersion(String version) {
+        // TODO what about linux? can someone test it?
+        Path path = Path.of(getDirectoryForVersion(version), "dotnet-csharpier");
+        return path.toString();
+    }
+}
diff --git a/Src/CSharpier.Rider/src/main/java/com/intellij/csharpier/FormattingService.java b/Src/CSharpier.Rider/src/main/java/com/intellij/csharpier/FormattingService.java
index 540413def..44f56ea6b 100644
--- a/Src/CSharpier.Rider/src/main/java/com/intellij/csharpier/FormattingService.java
+++ b/Src/CSharpier.Rider/src/main/java/com/intellij/csharpier/FormattingService.java
@@ -10,29 +10,30 @@
 import com.intellij.psi.PsiFile;
 import org.jetbrains.annotations.NotNull;
 
+import java.time.Duration;
+import java.time.Instant;
 import java.util.Collections;
 
 public class FormattingService {
-    Logger logger = Logger.getInstance(FormattingService.class);
+    Logger logger = CSharpierLogger.getInstance();
 
     @NotNull
     static FormattingService getInstance(@NotNull Project project) {
         return project.getService(FormattingService.class);
     }
 
-    public void format(@NotNull Document document,@NotNull Project project) {
+    public void format(@NotNull Document document, @NotNull Project project) {
         PsiFile psiFile = PsiDocumentManager.getInstance(project).getPsiFile(document);
         if (psiFile == null) {
             return;
         }
 
 
-
         if (!(psiFile.getLanguage().getID().equals("C#")
                 // while testing in intellij it doesn't know about c#
                 || (psiFile.getLanguage().getID().equals("TEXT") && psiFile.getName().endsWith(".cs")))
         ) {
-            this.logger.info("Skipping formatting because language was " + psiFile.getLanguage().getDisplayName());
+            this.logger.debug("Skipping formatting because language was " + psiFile.getLanguage().getDisplayName());
             return;
         }
 
@@ -47,8 +48,12 @@ public void format(@NotNull Document document,@NotNull Project project) {
         String filePath = virtualFile.getPath();
         String currentDocumentText = document.getText();
 
-        CSharpierService cSharpierService = CSharpierService.getInstance(project);
-        String result = cSharpierService.format(currentDocumentText, filePath);
+        CSharpierProcessProvider cSharpierProcessProvider = CSharpierProcessProvider.getInstance(project);
+        this.logger.info("Formatting started for " + filePath + ".");
+        Instant start = Instant.now();
+        String result = cSharpierProcessProvider.getProcessFor(filePath).formatFile(currentDocumentText, filePath);
+        Instant end = Instant.now();
+        this.logger.info("Formatted in " + (Duration.between(start, end).toMillis()) + "ms");
 
         if (result.length() > 0) {
             WriteCommandAction.runWriteCommandAction(project, () -> {
diff --git a/Src/CSharpier.Rider/src/main/java/com/intellij/csharpier/ICSharpierProcess.java b/Src/CSharpier.Rider/src/main/java/com/intellij/csharpier/ICSharpierProcess.java
index 857b3469f..47c4fb248 100644
--- a/Src/CSharpier.Rider/src/main/java/com/intellij/csharpier/ICSharpierProcess.java
+++ b/Src/CSharpier.Rider/src/main/java/com/intellij/csharpier/ICSharpierProcess.java
@@ -2,4 +2,5 @@
 
 public interface ICSharpierProcess {
     public String formatFile(String content, String fileName);
+    public void dispose();
 }
diff --git a/Src/CSharpier.Rider/src/main/java/com/intellij/csharpier/IProcessKiller.java b/Src/CSharpier.Rider/src/main/java/com/intellij/csharpier/IProcessKiller.java
new file mode 100644
index 000000000..d725f5f30
--- /dev/null
+++ b/Src/CSharpier.Rider/src/main/java/com/intellij/csharpier/IProcessKiller.java
@@ -0,0 +1,5 @@
+package com.intellij.csharpier;
+
+public interface IProcessKiller {
+    public void killRunningProcesses();
+}
diff --git a/Src/CSharpier.Rider/src/main/java/com/intellij/csharpier/InstallGlobalAction.java b/Src/CSharpier.Rider/src/main/java/com/intellij/csharpier/InstallGlobalAction.java
new file mode 100644
index 000000000..ed289d0e1
--- /dev/null
+++ b/Src/CSharpier.Rider/src/main/java/com/intellij/csharpier/InstallGlobalAction.java
@@ -0,0 +1,29 @@
+package com.intellij.csharpier;
+
+import com.intellij.notification.Notification;
+import com.intellij.notification.NotificationAction;
+import com.intellij.openapi.actionSystem.AnActionEvent;
+import com.intellij.openapi.util.NlsContexts;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+public class InstallGlobalAction extends NotificationAction {
+
+    private final IProcessKiller processKiller;
+
+    public InstallGlobalAction(
+        @Nullable @NlsContexts.NotificationContent String text,
+        IProcessKiller processKiller
+    ) {
+        super(text);
+        this.processKiller = processKiller;
+    }
+
+    @Override
+    public void actionPerformed(@NotNull AnActionEvent e, @NotNull Notification notification) {
+        String[] command2 = { "dotnet", "tool", "install", "-g", "csharpier" };
+        ProcessHelper.ExecuteCommand(command2, null, null);
+        this.processKiller.killRunningProcesses();
+    }
+}
+
diff --git a/Src/CSharpier.Rider/src/main/java/com/intellij/csharpier/InstallLocalAction.java b/Src/CSharpier.Rider/src/main/java/com/intellij/csharpier/InstallLocalAction.java
new file mode 100644
index 000000000..08cc9ba5e
--- /dev/null
+++ b/Src/CSharpier.Rider/src/main/java/com/intellij/csharpier/InstallLocalAction.java
@@ -0,0 +1,44 @@
+package com.intellij.csharpier;
+
+import com.intellij.notification.Notification;
+import com.intellij.notification.NotificationAction;
+import com.intellij.openapi.actionSystem.AnActionEvent;
+import com.intellij.openapi.diagnostic.Logger;
+import com.intellij.openapi.util.NlsContexts;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.io.File;
+import java.nio.file.Path;
+
+public class InstallLocalAction extends NotificationAction {
+    private Logger logger = CSharpierLogger.getInstance();
+    private final IProcessKiller processKiller;
+    private final String projectPath;
+
+    public InstallLocalAction(
+        @Nullable @NlsContexts.NotificationContent String text,
+        String projectPath,
+        IProcessKiller processKiller
+    ) {
+        super(text);
+        this.projectPath = projectPath;
+        this.processKiller = processKiller;
+    }
+
+    @Override
+    public void actionPerformed(@NotNull AnActionEvent e, @NotNull Notification notification) {
+        String manifestPath = Path.of(this.projectPath, ".config/dotnet-tools.json").toString();
+        this.logger.info("Installing csharpier in " + manifestPath);
+        if (!new File(manifestPath).exists())
+        {
+            String[] command = { "dotnet", "new", "tool-manifest" };
+            ProcessHelper.ExecuteCommand(command, null, new File(this.projectPath));
+        }
+
+        String[] command2 = { "dotnet", "tool", "install", "csharpier" };
+        ProcessHelper.ExecuteCommand(command2, null, new File(this.projectPath));
+
+        this.processKiller.killRunningProcesses();
+    }
+}
diff --git a/Src/CSharpier.Rider/src/main/java/com/intellij/csharpier/InstallerService.java b/Src/CSharpier.Rider/src/main/java/com/intellij/csharpier/InstallerService.java
new file mode 100644
index 000000000..635a98008
--- /dev/null
+++ b/Src/CSharpier.Rider/src/main/java/com/intellij/csharpier/InstallerService.java
@@ -0,0 +1,52 @@
+package com.intellij.csharpier;
+
+import com.intellij.notification.Notification;
+import com.intellij.notification.NotificationGroupManager;
+import com.intellij.notification.NotificationType;
+import com.intellij.openapi.diagnostic.Logger;
+import com.intellij.openapi.project.Project;
+import org.jetbrains.annotations.NotNull;
+
+public class InstallerService {
+    private final Logger logger = CSharpierLogger.getInstance();
+    private final Project project;
+    private boolean warnedAlready;
+
+    public InstallerService(@NotNull Project project) {
+        this.project = project;
+    }
+
+    @NotNull
+    static InstallerService getInstance(@NotNull Project project) {
+        return project.getService(InstallerService.class);
+    }
+
+    public void displayInstallNeededMessage(String directoryThatContainsFile, IProcessKiller processKiller) {
+        if (this.warnedAlready) {
+            return;
+        }
+        this.warnedAlready = true;
+        this.logger.warn("CSharpier was not found so files may not be formatted.");
+
+        this.logger.debug(directoryThatContainsFile);
+        this.logger.debug(this.project.getBasePath());
+
+        boolean isOnlyGlobal = !directoryThatContainsFile.replace('\\', '/').startsWith(this.project.getBasePath());
+
+        String message = isOnlyGlobal
+                ? ("CSharpier needs to be installed globally to format files in " + directoryThatContainsFile)
+                : "CSharpier needs to be installed to support formatting files";
+
+        Notification notification = NotificationGroupManager.getInstance().getNotificationGroup("CSharpier")
+                .createNotification(message, NotificationType.WARNING);
+
+        notification.addAction(new InstallGlobalAction("Install CSharpier Globally", processKiller));
+        if (!isOnlyGlobal) {
+            notification.addAction(
+                new InstallLocalAction("Install CSharpier Locally", project.getBasePath(), processKiller)
+            );
+        }
+
+        notification.notify(this.project);
+    }
+}
diff --git a/Src/CSharpier.Rider/src/main/java/com/intellij/csharpier/NullCSharpierProcess.java b/Src/CSharpier.Rider/src/main/java/com/intellij/csharpier/NullCSharpierProcess.java
index b5bd38f66..b1b7ce453 100644
--- a/Src/CSharpier.Rider/src/main/java/com/intellij/csharpier/NullCSharpierProcess.java
+++ b/Src/CSharpier.Rider/src/main/java/com/intellij/csharpier/NullCSharpierProcess.java
@@ -5,4 +5,9 @@ public class NullCSharpierProcess implements ICSharpierProcess {
     public String formatFile(String content, String fileName) {
         return "";
     }
+
+    @Override
+    public void dispose() {
+
+    }
 }
diff --git a/Src/CSharpier.Rider/src/main/java/com/intellij/csharpier/ProcessHelper.java b/Src/CSharpier.Rider/src/main/java/com/intellij/csharpier/ProcessHelper.java
new file mode 100644
index 000000000..0edba6fe6
--- /dev/null
+++ b/Src/CSharpier.Rider/src/main/java/com/intellij/csharpier/ProcessHelper.java
@@ -0,0 +1,49 @@
+package com.intellij.csharpier;
+
+import com.intellij.openapi.diagnostic.Logger;
+
+import java.io.*;
+import java.util.Map;
+
+public class ProcessHelper {
+
+    public static String ExecuteCommand(String[] command, Map<String, String> env, File workingDirectory) {
+        Logger logger = CSharpierLogger.getInstance();
+        try {
+            logger.debug("Running " + String.join(" ", command) + " in " + workingDirectory);
+            ProcessBuilder processBuilder = new ProcessBuilder(command);
+            if (env != null) {
+                processBuilder.environment().putAll(env);
+            }
+            if (workingDirectory != null) {
+                processBuilder.directory(workingDirectory);
+            }
+
+            Process process = processBuilder.start();
+            BufferedReader output = new BufferedReader(new InputStreamReader(process.getInputStream()));
+            BufferedReader error = new BufferedReader(new InputStreamReader(process.getErrorStream()));
+            StringBuilder result = new StringBuilder();
+            StringBuilder errorResult = new StringBuilder();
+            String line;
+            while ((line = output.readLine()) != null) {
+                result.append(line);
+                result.append("\n");
+            }
+            while ((line = error.readLine()) != null) {
+                errorResult.append(line);
+                errorResult.append("\n");
+            }
+
+            int exitVal = process.waitFor();
+            if (exitVal == 0){
+                return result.toString().trim();
+            }
+            logger.debug(errorResult.toString());
+        } catch (Exception e) {
+            logger.error(e.getMessage());
+            e.printStackTrace();
+
+        }
+        return null;
+    }
+}
diff --git a/Src/CSharpier.Rider/src/main/java/com/intellij/csharpier/ReformatWithCSharpierAction.java b/Src/CSharpier.Rider/src/main/java/com/intellij/csharpier/ReformatWithCSharpierAction.java
index 7244d4127..7510b9e8a 100644
--- a/Src/CSharpier.Rider/src/main/java/com/intellij/csharpier/ReformatWithCSharpierAction.java
+++ b/Src/CSharpier.Rider/src/main/java/com/intellij/csharpier/ReformatWithCSharpierAction.java
@@ -10,7 +10,7 @@
 import org.jetbrains.annotations.NotNull;
 
 public class ReformatWithCSharpierAction extends AnAction {
-    Logger logger = Logger.getInstance(ReformatWithCSharpierAction.class);
+    Logger logger = CSharpierLogger.getInstance();
 
     @Override
     public void actionPerformed(@NotNull AnActionEvent e) {
diff --git a/Src/CSharpier.Rider/src/main/java/com/intellij/csharpier/ReformatWithCSharpierOnSave.java b/Src/CSharpier.Rider/src/main/java/com/intellij/csharpier/ReformatWithCSharpierOnSave.java
index c2f3f08e1..b8a67e321 100644
--- a/Src/CSharpier.Rider/src/main/java/com/intellij/csharpier/ReformatWithCSharpierOnSave.java
+++ b/Src/CSharpier.Rider/src/main/java/com/intellij/csharpier/ReformatWithCSharpierOnSave.java
@@ -10,7 +10,7 @@
 import org.jetbrains.annotations.NotNull;
 
 public class ReformatWithCSharpierOnSave implements FileDocumentManagerListener {
-    Logger logger = Logger.getInstance(ReformatWithCSharpierAction.class);
+    Logger logger = CSharpierLogger.getInstance();
 
     @Override
     public void beforeDocumentSaving(@NotNull Document document) {
diff --git a/Src/CSharpier.Rider/src/main/resources/META-INF/plugin.xml b/Src/CSharpier.Rider/src/main/resources/META-INF/plugin.xml
index f691282e4..c5a01164e 100644
--- a/Src/CSharpier.Rider/src/main/resources/META-INF/plugin.xml
+++ b/Src/CSharpier.Rider/src/main/resources/META-INF/plugin.xml
@@ -7,9 +7,10 @@
     <depends>com.intellij.modules.platform</depends>
 
     <extensions defaultExtensionNs="com.intellij">
-        <projectService serviceImplementation="com.intellij.csharpier.CSharpierService"/>
+        <projectService serviceImplementation="com.intellij.csharpier.CSharpierProcessProvider"/>
         <projectService serviceImplementation="com.intellij.csharpier.FormattingService"/>
         <projectService serviceImplementation="com.intellij.csharpier.CSharpierSettings"/>
+        <projectService serviceImplementation="com.intellij.csharpier.InstallerService"/>
         <notificationGroup id="CSharpier" displayType="BALLOON"/>
         <postStartupActivity implementation="com.intellij.csharpier.CSharpierStartup"/>
         <fileDocumentManagerListener implementation="com.intellij.csharpier.ReformatWithCSharpierOnSave"/>
diff --git a/Src/CSharpier.VSCode/src/CSharpierProcessProvider.ts b/Src/CSharpier.VSCode/src/CSharpierProcessProvider.ts
index 22120cffe..f3813941a 100644
--- a/Src/CSharpier.VSCode/src/CSharpierProcessProvider.ts
+++ b/Src/CSharpier.VSCode/src/CSharpierProcessProvider.ts
@@ -18,8 +18,8 @@ export class CSharpierProcessProvider implements Disposable {
     csharpierVersionByDirectory: Record<string, string | undefined> = {};
     csharpierProcessesByVersion: Record<string, ICSharpierProcess | undefined> = {};
 
-    constructor(loggingService: Logger) {
-        this.logger = loggingService;
+    constructor(logger: Logger) {
+        this.logger = logger;
         this.installerService = new InstallerService(
             this.logger,
             this.killRunningProcesses,
diff --git a/Src/CSharpier.VSCode/src/CSharpierProcessSingleFile.ts b/Src/CSharpier.VSCode/src/CSharpierProcessSingleFile.ts
index d6626de3f..100399f99 100644
--- a/Src/CSharpier.VSCode/src/CSharpierProcessSingleFile.ts
+++ b/Src/CSharpier.VSCode/src/CSharpierProcessSingleFile.ts
@@ -7,8 +7,8 @@ export class CSharpierProcessSingleFile implements ICSharpierProcess {
     private readonly csharpierPath: string;
     private logger: Logger;
 
-    constructor(loggingService: Logger, csharpierPath: string) {
-        this.logger = loggingService;
+    constructor(logger: Logger, csharpierPath: string) {
+        this.logger = logger;
         this.csharpierPath = csharpierPath;
     }
 
diff --git a/Src/CSharpier.VSCode/src/FormattingService.ts b/Src/CSharpier.VSCode/src/FormattingService.ts
index 8e637692a..5ea86bc2d 100644
--- a/Src/CSharpier.VSCode/src/FormattingService.ts
+++ b/Src/CSharpier.VSCode/src/FormattingService.ts
@@ -8,10 +8,10 @@ export class FormattingService {
     csharpierProcessProvider: CSharpierProcessProvider;
 
     constructor(
-        loggingService: Logger,
+        logger: Logger,
         csharpierProcessProvider: CSharpierProcessProvider,
     ) {
-        this.logger = loggingService;
+        this.logger = logger;
         this.csharpierProcessProvider = csharpierProcessProvider;
 
         languages.registerDocumentFormattingEditProvider("csharp", {