feat: refactor and handle providers in the right way

Refactor to a more functional paradigm for all of the functionality.
Avoiding `this` should make it so that we can avoid all of the possible
errors that come with this.

Also, the code should be more readable now.

The big piece of this feature is making choosing the right provider 
work.
Previously, if you had more than one "provider" then it would not
properly go to definition.

Author: ryanolsonx

lib/atom-ide-definitions.js

@@ -0,0 +1,48 @@
+'use babel';
+
+async function goToDefinition(providerRegistry) {
+  if (!providerRegistry) {
+    return;
+  }
+
+  const editor = atom.workspace.getActiveTextEditor();
+  const provider = providerRegistry.getProviderForEditor(editor);
+
+  const position = editor.getCursorBufferPosition();
+  const result = await provider.getDefinition(editor, position);
+
+  if (!result) {
+    atom.notifications.addError('Sorry, no definitions found.');
+    return;
+  }
+
+  const { definitions } = result;
+
+  if (!definitions || definitions.length === 0) {
+    atom.notifications.addError('Sorry, no definitions found.');
+    return;
+  }
+
+  const {
+    path,
+    position: { row, column },
+  } = definitions[0];
+
+  if (editor.getPath() === path) {
+    const paneContainer = atom.workspace.paneContainerForItem(editor);
+    paneContainer.activate();
+
+    editor.setCursorBufferPosition([row, column]);
+    editor.scrollToBufferPosition([row, column], { center: true });
+  } else {
+    await atom.workspace.open(path, {
+      initialLine: row,
+      initialColumn: column,
+      searchAllPanes: true,
+      activatePane: true,
+      activateItem: true,
+    });
+  }
+}
+
+export default goToDefinition;

lib/goToDefinition.js

@@ -0,0 +1,33 @@
+'use babel';
+
+import { CompositeDisposable } from 'atom';
+import goToDefinition from './goToDefinition';
+import createProviderRegistry from './providerRegistry';
+
+function package() {
+  const providerRegistry = createProviderRegistry();
+  let subscriptions;
+
+  function activate() {
+    subscriptions = new CompositeDisposable();
+
+    subscriptions.add(
+      atom.commands.add('atom-workspace', {
+        'atom-ide-go-to-definition:go-to-definition': () =>
+          goToDefinition(providerRegistry),
+      })
+    );
+  }
+
+  function deactivate() {
+    subscriptions.dispose();
+  }
+
+  function consumeDefinitionsService(provider) {
+    providerRegistry.addProvider(provider);
+  }
+
+  return { activate, deactivate, consumeDefinitionsService };
+}
+
+export default package();

lib/main.js

@@ -0,0 +1,39 @@
+'use babel';
+
+import { Disposable } from 'atom';
+
+function providerRegistry() {
+  let providers = [];
+
+  function addProvider(provider) {
+    const index = providers.findIndex(p => provider.priority > p.priority);
+    if (index === -1) {
+      providers.push(provider);
+    } else {
+      providers.splice(index, 0, provider);
+    }
+
+    return new Disposable(() => removeProvider(provider));
+  }
+
+  function removeProvider(provider) {
+    const index = providers.indexOf(provider);
+    if (index !== -1) {
+      providers.splice(index, 1);
+    }
+  }
+
+  function getProviderForEditor(editor) {
+    const grammar = editor.getGrammar().scopeName;
+
+    return providers.find(
+      provider =>
+        !provider.grammarScopes ||
+        provider.grammarScopes.indexOf(grammar) !== -1
+    );
+  }
+
+  return { addProvider, getProviderForEditor };
+}
+
+export default providerRegistry;

lib/providerRegistry.js

@@ -1,6 +1,6 @@
 {
   "name": "atom-ide-definitions",
-  "main": "./lib/atom-ide-definitions",
+  "main": "./lib/main",
   "version": "0.1.3",
   "description": "A replacement for the Definitions functionality that was originally part of the Atom IDE package from Facebook.",
   "keywords": [