Rework sync method to be more verbose and fix bug with bigger amounts of frames

Author: kriskbx

gtt-sync.js

@@ -15,11 +15,18 @@ Cli.verbose = program.verbose;
 let config = new Config(process.cwd()).set('proxy', program.proxy),
     tasks = new Tasks(config);
 
-tasks.syncResolve()
+tasks.syncInit()
+    .then(() => tasks.sync.frames.length === 0 ? process.exit(0) : null)
     .then(() => {
-        if (tasks.sync.frames.length === 0) process.exit(0);
-        return Cli.bar(`${Cli.process}  Syncing time records...`, tasks.sync.frames.length)
+        Cli.bar(`${Cli.fetch}  Fetching issues & merge requests...`, tasks.sync.frames.length);
+        return tasks.syncResolve(Cli.advance);
+    })
+    .then(() => {
+        Cli.bar(`${Cli.process}  Processing issues & merge requests...`, tasks.sync.frames.length);
+        return tasks.syncNotes(Cli.advance);
+    })
+    .then(() => {
+        Cli.bar(`${Cli.update}  Syncing time records...`, tasks.sync.frames.length);
+        return tasks.syncUpdate(Cli.advance)
     })
-    .then(() => tasks.syncNotes())
-    .then(() => tasks.syncUpdate(Cli.advance))
     .catch(error => Cli.x(error));

include/cli.js

@@ -18,6 +18,10 @@ class cli {
     /*
      * emojis
      */
+    static get update() {
+        return '⏱';
+    }
+
     static get print() {
         return '🖨';
     }

include/tasks.js

@@ -20,21 +20,29 @@ class tasks {
     }
 
     /**
-     * Filter frames that need an update and resolve merge_requests and issues
-     * respectively.
+     * Filter frames that need an update
      * @returns {Promise}
      */
-    syncResolve() {
+    syncInit() {
         this.sync.frames = new FrameCollection(this.config);
 
+        // filter out frames, that don't need an update
+        this.sync.frames.filter(frame => !(Math.ceil(frame.duration) === _.reduce(frame.notes, (n, m) => (n + m.time), 0)));
+
+        return new Promise(r => r());
+    }
+
+    /**
+     * Resolve merge_requests and issues
+     * respectively.
+     * @returns {Promise}
+     */
+    syncResolve(callback) {
         this.sync.resources = {
             issue: {},
             merge_request: {}
         };
 
-        // filter out frames, that don't need an update
-        this.sync.frames.filter(frame => !(Math.ceil(frame.duration) === _.reduce(frame.notes, (n, m) => (n + m.time), 0)));
-
         // resolve issues and merge requests
         return this.sync.frames.forEach((frame, done) => {
             let project = frame.project,
@@ -48,26 +56,35 @@ class tasks {
             this.sync.resources[type][id] = new classes[type](this.config, {});
             this.sync.resources[type][id]
                 .make(project, id)
-                .then(() => done())
+                .then(() => {
+                    if (callback) callback();
+                    done();
+                })
                 .catch(error => done(`Could not resolve ${type} ${id} on "${project}"`));
         })
     }
 
     /**
      * Get notes for all frames.
      */
-    syncNotes() {
+    syncNotes(callback) {
         return this.sync.frames.forEach((frame, done) => {
             let project = frame.project,
                 type = frame.resource.type,
                 id = frame.resource.id,
                 notes;
 
-            if ((notes = this.sync.resources[type][id].notes) && notes.length > 0) return;
+            if ((notes = this.sync.resources[type][id].notes) && notes.length > 0) {
+                if (callback) callback();
+                return done();
+            }
 
             this.sync.resources[type][id]
                 .getNotes()
-                .then(() => done())
+                .then(() => {
+                    if (callback) callback();
+                    done();
+                })
                 .catch(error => done(`Could not get notes from ${type} ${id} on "${project}"`));
         });
     }
@@ -92,22 +109,24 @@ class tasks {
     }
 
     _addTime(frame, time) {
-        return new Promise((resolve, reject) => {
+        return new Promise(async function(resolve, reject) {
             let resource = this.sync.resources[frame.resource.type][frame.resource.id];
 
-            resource
-                .createTime(Math.ceil(time))
-                .then(() => resource.getNotes())
-                .then(() => {
-                    frame.notes.push({
-                        id: resource.notes[0].id,
-                        time: Math.ceil(time)
-                    });
-                    frame.write();
-                    resolve();
-                })
-                .catch(error => reject(error))
-        });
+            try {
+                await resource.createTime(Math.ceil(time));
+                await resource.getNotes();
+            } catch(error) {
+                return reject(error);
+            }
+
+            frame.notes.push({
+                id: resource.notes[0].id,
+                time: Math.ceil(time)
+            });
+
+            frame.write();
+            resolve();
+        }.bind(this));
     }
 
     /**

models/frameCollection.js

@@ -6,33 +6,38 @@ class frameCollection extends Base {
     constructor(config) {
         super(config);
 
-        this.frames = Fs.readDir(config.frameDir);
+        this.frames =
+            Fs.readDir(config.frameDir)
+                .map(file => {
+                    try {
+                        return Frame.fromFile(this.config, Fs.join(this.config.frameDir, file));
+                    } catch (e) {
+                        return false;
+                    }
+                })
+                .filter(frame => frame);
     }
 
     filter(func) {
         let arr = [];
 
-        this.frames.forEach(file => {
-            let frame = Frame.fromFile(this.config, Fs.join(this.config.frameDir, file));
+        this.frames.forEach(frame => {
             if (frame.stop === false) {
-                return;
+                return false;
             }
 
             if (func(frame)) {
-                arr.push(file);
+                arr.push(frame);
             }
-        });
 
-        this.frames = arr;
+            this.frames = arr;
+        });
     }
 
     forEach(iterator) {
-        return this.parallel(this.frames, (file, done) => {
-            let frame = Frame.fromFile(this.config, Fs.join(this.config.frameDir, file));
-            if (frame.stop === false) return done();
+        let promise = this.parallel(this.frames, iterator);
 
-            iterator(frame, done);
-        });
+        return promise;
     }
 
     get length() {