[grammar-finder] Add new Core Package

packages/grammar-finder/README.md

@@ -0,0 +1,30 @@
+# Grammar-Finder
+
+Discover language grammars for unrecognized files.
+
+## AutoFind
+
+With 'AutoFind' enabled, when Pulsar fails to locate a grammar for the file you've just opened, defaulting to 'Plain Text', `grammar-finer` will automatically contact the Pulsar Package Registry in search of a community package that provides syntax highlighting for the file currently opened.
+
+If any packages are found you can easily view the whole list and install the one that looks best.
+
+When an 'AutoFind' notification appears you can quickly select:
+  * 'View Available Packages' to view the packages found.
+  * 'Disable Grammar-Finder for <ext>' to add this extension to the `ignoreExtList`.
+  * 'Disable AutoFind' to disable 'AutoFind' completely.
+
+## Command Palette
+
+`grammar-finder` adds `grammar-finder:find-grammars-for-file` to the Command Palette, so that at any time you can check if any community packages provide syntax highlighting for the file you are currently working in.
+
+This makes it possible to find grammars for _recognized_ file types — or for unrecognized file types if you’ve disabled `autoFind`.
+
+## Configuration
+
+### `autoFind`
+
+When enabled, `autoFind` will show a notification inviting you to install a suitable grammar for an unrecognized file type.
+
+### `ignoreExtList`
+
+Any file extensions can be added to this list to disable all automatic checks for community packages for those file types. Choosing the “Disable `grammar-finder` for X” option on an `autoFind` notification will automatically add a given file extension to this list. This field should contain a comma-separated list of file extensions without any leading `.`s.

packages/grammar-finder/lib/main.js

@@ -0,0 +1,192 @@
+const { CompositeDisposable } = require("atom");
+const path = require("path");
+const PackageListView = require("./package-list-view.js");
+
+class GrammarFinder {
+  activate() {
+
+    // This local variable is intended to act as 'session' storage, or editing
+    // session storage. Where the next time the editor is opened it's info is gone
+    this.promptedForExt = [];
+
+    atom.grammars.emitter.on("did-auto-assign-grammar", async (data) => {
+      if (!atom.config.get("grammar-finder.autoFind")) {
+        // autofind is turned off
+        return;
+      }
+
+      let extOrFalse = this.inspectAssignment(data);
+      if (!extOrFalse) {
+        // We got false from inspectAssignment() we don't need to act
+        return;
+      }
+
+      const ext = extOrFalse.replace(".", "");
+
+      const ignoreExtList = atom.config.get("grammar-finder.ignoreExtList");
+
+      if (ignoreExtList.includes(ext)) {
+        // we have been told to ignore this ext
+        return;
+      }
+
+      if (this.promptedForExt.includes(ext)) {
+        // If we have already prompted for this extension in this editing session
+        return;
+      }
+
+      const packages = await this.checkForGrammars(ext);
+
+      if (packages.length === 0) {
+        // No packages were found that support this grammar
+        return;
+      }
+
+      this.promptedForExt.push(ext);
+
+      // Lets notify the user about the found packages
+      this.notify(packages, ext, "Pulsar couldn't identify an installed grammar for this file.");
+    });
+
+    this.disposables = new CompositeDisposable();
+
+    this.disposables.add(
+      atom.commands.add("atom-workspace", {
+        "grammar-finder:find-grammars-for-file": async () => {
+          // Here we can let users find a grammar for the current file, even if
+          // it's already correctly identified
+          const grammar = atom.workspace.getActiveTextEditor().getGrammar();
+          const buffer = atom.workspace.getActiveTextEditor().buffer;
+
+          let extOrFalse = this.inspectAssignment(
+            {
+              grammar: grammar,
+              buffer: buffer
+            },
+            {
+              ignoreScope: true
+            }
+          );
+
+          if (!extOrFalse) {
+            // We didn't find any grammar, since this is manually invoked we may want to alert
+            atom.notifications.addInfo("Grammar-Finder was unable to identify the file.", { dismissable: true });
+            return;
+          }
+
+          let ext = extOrFalse.replace(".", "");
+
+          const ignoreExtList = atom.config.get("grammar-finder.ignoreExtList");
+
+          if (ignoreExtList.includes(ext)) {
+            // we have been told to ignore this ext, since manually invoked we may want to alert
+            atom.notifications.addInfo("This file is present on Grammar-Finder's ignore list.", { dismissable: true });
+            return;
+          }
+
+          const packages = await this.checkForGrammars(ext);
+
+          if (packages.length === 0) {
+            // No packages were found that support this grammar
+            // since manuall invoked we may want to notify
+            atom.notifications.addInfo(`Unable to locate any Grammars for '${ext}'.`, { dismissable: true });
+            return;
+          }
+
+          // Lets notify the user about the found packages
+          this.notify(packages, ext, `'${packages.length}' Installable Grammars are available for '${ext}'.`);
+        }
+      })
+    );
+  }
+
+  deactivate() {
+    this.superagent = null;
+  }
+
+  inspectAssignment(data, opts = {}) {
+    console.log(`grammar-finder.inspectAssignment(${data.grammar.scopeName}, ${data.buffer.getPath()})`);
+    // data = { grammar, buffer }
+    // Lets first make sure that the grammar returned is one where no
+    // grammar could be found for the file.
+
+    if (data.grammar.scopeName === "text.plain.null-grammar" || opts.ignoreScope) {
+      const filePath = data.buffer.getPath();
+
+      if (typeof filePath !== "string") {
+        return false;
+      }
+
+      const parsed = path.parse(filePath);
+      // NodeJS thinks that if the `.` is the first character of a filename
+      // then it doesn't count as an extension. But according to our handling
+      // in Pulsar, the same isn't true.
+      let ext = false;
+
+      if (typeof parsed.ext === "string" && parsed.ext.length > 0) {
+        ext = parsed.ext;
+      } else if (typeof parsed.name === "string" && parsed.name.length > 0) {
+        ext = parsed.name;
+      }
+
+      console.log(`File: ${filePath} - Ext: ${ext}`);
+
+      return ext;
+    } else {
+      return false;
+    }
+  }
+
+  async checkForGrammars(ext) {
+    this.superagent ??= require("superagent");
+
+    const res = await this.superagent
+      .get("https://api.pulsar-edit.dev/api/packages")
+      .set("User-Agent", "Pulsar.Grammar-Finder")
+      .query({ fileExtension: ext });
+
+    if (res.status !== 200) {
+      // Return empty array
+      console.error(`Grammar-Finder received status '${res.status}' from the backend: ${res.body}`);
+      return [];
+    }
+
+    return res.body;
+  }
+
+  notify(packages, ext, title) {
+    atom.notifications.addInfo(
+      title,
+      {
+        description: "Would you like to see installable packages that **may** support this file type?",
+        dismissable: true,
+        buttons: [
+          {
+            text: "View Available Packages",
+            onDidClick: () => {
+              let packageListView = new PackageListView(packages);
+              packageListView.toggle();
+            }
+          },
+          {
+            text: `Don't suggest packages for '${ext}' files`,
+            onDidClick: () => {
+              let ignoreExtList = atom.config.get("grammar-finder.ignoreExtList");
+              ignoreExtList.push(ext);
+              atom.config.set("grammar-finder.ignoreExtList", ignoreExtList);
+            }
+          },
+          {
+            text: "Never suggest packages for unrecognized files",
+            onDidClick: () => {
+              atom.config.set("grammar-finder.autoFind", false);
+            }
+          }
+        ]
+      }
+    );
+
+  }
+}
+
+module.exports = new GrammarFinder();

packages/grammar-finder/lib/package-list-view.js

@@ -0,0 +1,94 @@
+const SelectListView = require("atom-select-list");
+
+module.exports =
+class PackageListView {
+  constructor(packageList) {
+
+    this.packageList = packageList;
+
+    this.packageListView = new SelectListView({
+      itemsClassList: [ "mark-active" ],
+      items: [],
+      filterKeyForItem: (pack) => pack.name,
+      elementForItem: (pack) => {
+        const packageCard = document.createElement("div");
+        packageCard.classList.add("package-card");
+
+        const body = document.createElement("div");
+        body.classList.add("body");
+
+        const cardName = document.createElement("h4");
+        cardName.classList.add("card-name");
+
+        const packageName = document.createElement("a");
+        packageName.classList.add("package-name");
+        packageName.textContent = pack.name;
+        packageName.href = `https://web.pulsar-edit.dev/packages/${pack.name}`;
+        cardName.appendChild(packageName);
+
+        const packageVersion = document.createElement("span");
+        packageVersion.classList.add("package-version");
+        packageVersion.textContent = pack.metadata.version;
+        cardName.appendChild(packageVersion);
+
+        const packageDescription = document.createElement("span");
+        packageDescription.classList.add("package-description");
+        packageDescription.textContent = pack.metadata.description;
+
+        body.appendChild(cardName);
+        body.appendChild(packageDescription);
+
+        packageCard.appendChild(body);
+
+        return packageCard;
+      },
+      didConfirmSelection: (pack) => {
+        this.cancel();
+        // Then we defer to `settings-view` to install the package
+        atom.workspace.open(`atom://settings-view/show-package?package=${pack.name}`);
+      },
+      didCancelSelection: () => {
+        this.cancel();
+      }
+    });
+
+    this.packageListView.element.classList.add("grammar-finder");
+  }
+
+  destroy() {
+    this.cancel();
+    this.packageList = null;
+    return this.packageListView.destroy();
+  }
+
+  cancel() {
+    if (this.panel != null) {
+      this.panel.destroy();
+    }
+    this.panel = null;
+
+    if (this.previouslyFocusedElement) {
+      this.previouslyFocusedElement.focus();
+      this.previouslyFocusedElement = null;
+    }
+  }
+
+  attach() {
+    this.previouslyFocusedElement = document.activeElement;
+    if (this.panel == null) {
+      this.panel = atom.workspace.addModalPanel({ item: this.packageListView });
+    }
+    this.packageListView.focus();
+    this.packageListView.reset();
+  }
+
+  async toggle() {
+    if (this.panel != null) {
+      this.cancel();
+      return;
+    }
+
+    await this.packageListView.update({ items: this.packageList });
+    this.attach();
+  }
+}