Merge pull request #3 from pulsar-edit/decaf-and-add-consumer-grouping

Decaf and add consumer grouping

Author: savetheclocktower

spec/service-hub-spec.coffee

@@ -48,6 +48,36 @@ describe "ServiceHub", ->
       hub.provide "b", "1.0.0", z: 3
       expect(services).toEqual [{x: 1}, {y: 2}]
 
+    it "invokes the callback with the newest version of a service provided in a given batch when 'consume' is called with an object", ->
+      hub.provide "a",
+        "1.0.0": {w: 1}
+        "1.1.0": {x: 2}
+      hub.provide "a",
+        "1.2.0": {y: 3}
+      hub.provide "b",
+        "1.0.0": {z: 4}
+      hub.provide "a",
+        "1.1.0": { should_not_be_used: 999 },
+        "1.2.0": { v: 0 }
+      hub.provide "a",
+        "1.0.0": { w: -1 }
+
+      services100 = []
+      services110 = []
+      services120 = []
+
+      hub.consume "a", {
+        '1.0.0': (s) -> services100.push(s),
+        '1.1.0': (s) -> services110.push(s),
+        '1.2.0': (s) -> services120.push(s)
+      }
+
+      # The first and third `a` providers should fulfill with only the higher
+      # of the two services they expose.
+      expect(services100).toEqual([{ w: -1 }])
+      expect(services110).toEqual([{ x: 2 }])
+      expect(services120).toEqual([{ y: 3 }, { v: 0 }])
+
     it "can specify a key path that navigates into the contents of a service", ->
       hub.provide "a", "1.0.0", b: c: 1
       hub.provide "a", "1.0.0", d: e: 2

src/consumer.coffee

@@ -0,0 +1,51 @@
+const {Range} = require('semver');
+
+class Consumer {
+  constructor(keyPath, versionRange, callback) {
+    this.keyPath = keyPath;
+
+    let versionConsumerObj;
+    if (typeof versionRange === 'object') {
+      // If the second argument is not a string, it must be an object of
+      // version/function pairs, and the third argument must be omitted.
+      if (typeof callback === 'function') {
+        throw new TypeError('versionRange must be a string or an object of version/function pairs');
+      }
+      versionConsumerObj = versionRange;
+    } else {
+      versionConsumerObj = { [versionRange]: callback };
+    }
+
+    // A consumer can expose multiple version ranges and multiple callback
+    // functions. When matching up a single `Provider` to a single `Consumer`,
+    // only the best version match (the highest version that satisfies at least
+    // one version range) will be used.
+    this.versionRangeMap = new Map();
+    for (let [versionRange, callback] of Object.entries(versionConsumerObj)) {
+      let range = new Range(versionRange);
+      this.versionRangeMap.set(range, callback);
+    }
+  }
+
+  // If the consumer defines several version ranges, some of which may overlap,
+  // the first range we encounter that matches the given version will be used.
+  //
+  // Since a consumer can list version ranges of arbitrary complexity, we
+  // cannot choose the "highest" version range, nor can we specify a logical
+  // order in which the version ranges are visited. Theoretically, they should
+  // be enumerated in the order they're defined, but this is not a guarantee
+  // made by the language. (Enumeration order is guaranteed for the map, but
+  // not for the bare object we used to create the map.)
+  //
+  // Thus it's up to the developer to structure these version ranges to rule
+  // out overlaps.
+  callbackForVersion (targetVersion) {
+    for (let [range, callback] of this.versionRangeMap) {
+      if (!range.test(targetVersion)) continue;
+      return callback;
+    }
+    return undefined;
+  }
+}
+
+module.exports = Consumer;

src/consumer.js

@@ -0,0 +1,39 @@
+
+function getValueAtKeyPath (object, keyPath) {
+  const keys = splitKeyPath(keyPath);
+  for (var key of keys) {
+    object = object[key];
+    if (object == null) { return; }
+  }
+  return object;
+}
+
+function setValueAtKeyPath (object, keyPath, value) {
+  const keys = splitKeyPath(keyPath);
+  while (keys.length > 1) {
+    var key = keys.shift();
+    object[key] ??= {};
+    object = object[key];
+  }
+  object[keys.shift()] = value;
+}
+
+function splitKeyPath (keyPath) {
+  if (keyPath == null) { return []; }
+  let startIndex = 0;
+  const keys = [];
+  for (let i = 0; i < keyPath.length; i++) {
+    var char = keyPath[i];
+    if ((char === '.') && ((i === 0) || (keyPath[i-1] !== '\\'))) {
+      keys.push(keyPath.substring(startIndex, i));
+      startIndex = i + 1;
+    }
+  }
+  keys.push(keyPath.substr(startIndex, keyPath.length));
+  return keys;
+}
+
+module.exports = {
+  getValueAtKeyPath,
+  setValueAtKeyPath
+};

src/helpers.coffee

@@ -0,0 +1,61 @@
+const {gt, SemVer} = require('semver');
+const {CompositeDisposable} = require('event-kit');
+
+const {getValueAtKeyPath, setValueAtKeyPath} = require('./helpers');
+
+class Provider {
+  constructor(keyPath, servicesByVersion) {
+    this.consumersDisposable = new CompositeDisposable;
+    this.servicesByVersion = {};
+    this.versions = [];
+
+    for (let version in servicesByVersion) {
+      let service = servicesByVersion[version];
+      this.servicesByVersion[version] = {};
+      this.versions.push(new SemVer(version));
+      setValueAtKeyPath(this.servicesByVersion[version], keyPath, service);
+    }
+
+    this.versions.sort((a, b) => b.compare(a));
+  }
+
+  provide(consumer) {
+    // A consumer can specify multiple version ranges, each with its own
+    // callback. It's up to us to (a) find all the versions we advertise that
+    // match up with versions that the consumer can consume, then (b) choose
+    // the highest version number among these.
+    let highestVersion;
+    let highestVersionCallback;
+    let highestVersionValue;
+
+    for (let version of this.versions) {
+      let callback = consumer.callbackForVersion(version);
+      if (!callback) continue;
+
+      // This version matches. Does the service name match?
+      let value = getValueAtKeyPath(this.servicesByVersion[version.toString()], consumer.keyPath);
+      if (!value) continue;
+
+      let isHighestVersion = !highestVersion || gt(version, highestVersion);
+      if (!isHighestVersion) continue;
+
+      highestVersion = version;
+      highestVersionCallback = callback;
+      highestVersionValue = value;
+    }
+
+    if (!highestVersionCallback) return;
+
+    let consumerDisposable = highestVersionCallback.call(null, highestVersionValue);
+
+    if (typeof consumerDisposable?.dispose === 'function') {
+      this.consumersDisposable.add(consumerDisposable);
+    }
+  }
+
+  destroy() {
+    this.consumersDisposable.dispose();
+  }
+}
+
+module.exports = Provider;