Small tweaks.

lib/core/Manager.js

@@ -387,7 +387,7 @@ Manager.prototype._dissect = function () {
 };
 
 Manager.prototype._extendNotification = function (notification, decEndpoint) {
-    notification.from = decEndpoint.name || decEndpoint.registryName || decEndpoint.resolverName;
+    // Add endpoint to the data
     notification.data = notification.data || {};
     notification.data.endpoint = {
         name: decEndpoint.name,
@@ -395,6 +395,12 @@ Manager.prototype._extendNotification = function (notification, decEndpoint) {
         target: decEndpoint.target
     };
 
+    // Add from
+    notification.from = decEndpoint.name || decEndpoint.registryName;
+    if (!notification.from && notification.data.resolver) {
+        notification.from = notification.data.resolver.getName();
+    }
+
     return notification;
 };
 

lib/core/PackageRepository.js

@@ -23,7 +23,9 @@ function PackageRepository(config) {
 // -----------------
 
 PackageRepository.prototype.fetch = function (decEndpoint) {
-    var res;
+    var resolver;
+    var pkgMeta;
+    var canonicalPkg;
     var deferred = Q.defer();
     var that = this;
 
@@ -31,29 +33,26 @@ PackageRepository.prototype.fetch = function (decEndpoint) {
     resolverFactory(decEndpoint, this._registryClient, this._config)
     // Decide if we retrieve from the cache or not
     // Also decide we if validate the cached entry or not
-    .then(function (resolver) {
-        res = resolver;
-
-        // Set the resolver name in the decEndpoint
-        decEndpoint.resolverName = resolver.getName();
+    .then(function (res) {
+        resolver = res;
 
         // If force flag is used, bypass cache
         if (that._config.force) {
-            deferred.notify({
-                level: 'action',
-                id: 'resolve',
-                message: resolver.getSource() + '#' + resolver.getTarget()
+            return that._resolve(resolver)
+            // We have to listen to the progress and return it back
+            // otherwise it won't be propagated (wtf?)
+            .progress(function (notification) {
+                return notification;
             });
-            return that._resolve(resolver);
         }
 
         // Note that we use the resolver methods to query the
         // cache because transformations/normalisations can occur
         return that._resolveCache.retrieve(resolver.getSource(), resolver.getTarget())
         // Decide if we can use the one from the resolve cache
-        .spread(function (canonicalPkg, pkgMeta) {
+        .spread(function (canonical, meta) {
             // If there's no package in the cache
-            if (!canonicalPkg) {
+            if (!canonical) {
                 // And the offline flag is passed, error out
                 if (that._config.offline) {
                     throw createError('No cached version for ' + resolver.getSource() + '#' + resolver.getTarget(), 'ENOCACHE', {
@@ -64,25 +63,20 @@ PackageRepository.prototype.fetch = function (decEndpoint) {
                 // Otherwise, we have to resolve it
                 deferred.notify({
                     level: 'info',
-                    id: 'uncached',
-                    message: 'No cached version for ' + resolver.getSource() + '#' + resolver.getTarget()
-                });
-                deferred.notify({
-                    level: 'action',
-                    id: 'resolve',
-                    message: resolver.getSource() + '#' + resolver.getTarget()
+                    id: 'not-cached',
+                    message: resolver.getSource() + (resolver.getTarget() ? '#' + resolver.getTarget() : '')
                 });
 
                 return that._resolve(resolver);
             }
 
+            canonicalPkg = canonical;
+            pkgMeta = meta;
+
             deferred.notify({
                 level: 'info',
                 id: 'cached',
-                message: resolver.getSource() + (pkgMeta._release ? '#' + pkgMeta._release: '') + ' entry',
-                data: {
-                    pkgMeta: pkgMeta
-                }
+                message: resolver.getSource() + (pkgMeta._release ? '#' + pkgMeta._release : '')
             });
 
             // If offline flag is used, use directly the cached one
@@ -94,11 +88,9 @@ PackageRepository.prototype.fetch = function (decEndpoint) {
             process.nextTick(function () {
                 deferred.notify({
                     level: 'action',
-                    id: 'check',
-                    message: resolver.getSource() + '#' + resolver.getTarget() + ' for newer version',
-                    data: {
-                        pkgMeta: pkgMeta
-                    }
+                    id: 'validate',
+                    message: (pkgMeta._release ? pkgMeta._release + ' against ': '') +
+                             resolver.getSource() + (resolver.getTarget() ? '#' + resolver.getTarget() : '')
                 });
             });
 
@@ -114,15 +106,7 @@ PackageRepository.prototype.fetch = function (decEndpoint) {
                 deferred.notify({
                     type: 'info',
                     id: 'new',
-                    message: 'version for ' + resolver.getSource() + '#' + resolver.getTarget(),
-                    data: {
-                        pkgMeta: pkgMeta
-                    }
-                });
-                deferred.notify({
-                    level: 'action',
-                    id: 'resolve',
-                    message: resolver.getSource() + '#' + resolver.getTarget()
+                    message: 'version for ' + resolver.getSource() + '#' + resolver.getTarget()
                 });
 
                 return that._resolve(resolver);
@@ -130,12 +114,21 @@ PackageRepository.prototype.fetch = function (decEndpoint) {
         });
     })
     .then(deferred.resolve, deferred.reject, function (notification) {
-        // Store the resolver info for each notification
-        notification.resolver = {
-            name: res.getName(),
-            source: res.getSource(),
-            target: res.getTarget()
-        };
+        // Store the resolver info in each notification
+        if (resolver) {
+            notification.resolver = {
+                name: resolver.getName(),
+                source: resolver.getSource(),
+                target: resolver.getTarget()
+            };
+        }
+
+        // Store the canonical package and it's meta in each notification
+        if (canonicalPkg) {
+            notification.data = notification.data || {};
+            notification.data.canonicalPkg = canonicalPkg;
+            notification.data.pkgMeta = pkgMeta;
+        }
 
         deferred.notify(notification);
     });
@@ -153,8 +146,18 @@ PackageRepository.prototype.empty = function (name) {
 // ---------------------
 
 PackageRepository.prototype._resolve = function (resolver) {
+    var deferred = Q.defer();
+
+    process.nextTick(function () {
+        deferred.notify({
+            level: 'action',
+            id: 'resolve',
+            message: resolver.getSource() + '#' + resolver.getTarget()
+        });
+    });
+
     // Resolve the resolver
-    return resolver.resolve()
+    resolver.resolve()
     // Store in the cache
     .then(function (canonicalPkg) {
         return this._resolveCache.store(canonicalPkg, resolver.getPkgMeta());
@@ -162,7 +165,10 @@ PackageRepository.prototype._resolve = function (resolver) {
     // Resolve promise with canonical package and package meta
     .then(function (dir) {
         return [dir, resolver.getPkgMeta()];
-    }.bind(this));
+    }.bind(this))
+    .then(deferred.resolve, deferred.reject, deferred.notify);
+
+    return deferred.promise;
 };
 
 module.exports = PackageRepository;