@beauraines/rtm-cli 1.5.2

package/src/utils/log.js

@@ -0,0 +1,163 @@
+'use strict';
+
+const chalk = require('chalk');
+const spinner = require('ora')();
+
+
+/**
+ * Log the specified text
+ * @param {string} text The text to log
+ * @param {boolean} [newline=true] End the log with a newline
+ */
+function log(text="", newline=true) {
+  let nl = newline ? '\n' : '';
+  process.stdout.write(text + nl);
+}
+
+/**
+ * Log the specified text as an Info block
+ * @param {string} text The text to log
+ * @param {boolean} [newline=true] End the log with a newline
+ */
+log.info = function(text, newline=true) {
+  if ( _plain() ) {
+    return log(text, newline);
+  }
+
+  let nl = newline ? '\n' : '';
+  process.stdout.write(chalk.bgYellow.black(" " + text + " " + nl));
+};
+
+
+/**
+ * Log the specified text with the specified `chalk` style
+ * @param {string} text The text to log
+ * @param {string} [style=reset] The chalk style attributes (ex: bgYellow.black)
+ * @param {boolean} [newline=false] End the log with a newline
+ */
+log.style = function(text, style, newline) {
+  if ( style === undefined && newline === undefined ) {
+    style = 'reset';
+    newline = false;
+  }
+  else if ( newline === undefined && typeof style === 'boolean' ) {
+    newline = style;
+    style = 'reset';
+  }
+  else if ( newline === undefined ) {
+    newline = false;
+  }
+
+  if ( _plain() ) {
+    return log(text, newline);
+  }
+
+  let nl = newline ? '\n' : '';
+  let ch = chalk;
+  let parts = style.split('.');
+  for ( let i = 0; i < parts.length; i++ ) {
+    let part = parts[i];
+    ch = ch[part];
+  }
+  process.stdout.write(ch(text + nl));
+};
+
+
+/**
+ * Log an Error: use the spinner fail function
+ * @param {string} text The text to log
+ */
+log.error = function(text) {
+  log.spinner.error(text);
+};
+
+
+/**
+ * Spinner-related functions
+ * @type {{start: log.spinner.start, stop: log.spinner.stop, success: log.spinner.success, error: log.spinner.error}}
+ */
+log.spinner = {
+
+  /**
+   * Start the spinner with the specified text
+   * @param {string} text The text to log
+   */
+  start: function(text) {
+    if ( !_plain() && _status() ) {
+      spinner.start(text);
+    }
+  },
+
+  /**
+   * Stop and clear the spinner
+   */
+  stop: function() {
+    if ( !_plain() && _status() ) {
+      spinner.stop();
+    }
+  },
+
+  /**
+   * Set the spinner as a success with the specified text
+   * @param {string} text The text to log
+   */
+  success: function(text) {
+    if ( _status() ) {
+      if ( !_plain() ) {
+        spinner.succeed(text);
+      }
+      else {
+        log("[ok] " + text);
+      }
+    }
+  },
+
+  /**
+   * Set the spinner as an error with the specified text
+   * @param {string} text The text to log
+   */
+  error: function(text) {
+    if ( _status() ) {
+      if ( !_plain() ) {
+        spinner.fail(text);
+      }
+      else {
+        log("[error] " + text);
+      }
+    }
+  },
+
+  /**
+   * Set the spinner as a warning with the specified text
+   * @param {string} text The text to log
+   */
+  warn: function(text) {
+    if ( _status() ) {
+      if ( !_plain() ) {
+        spinner.warn(text);
+      }
+      else {
+        log("[warning] " + text);
+      }
+    }
+  }
+
+};
+
+
+/**
+ * Check for a --plain flag
+ * @returns {boolean}
+ * @private
+ */
+function _plain() {
+  return require('./config.js').get().plain;
+}
+
+function _status() {
+  return require('./config.js').get().status;
+}
+
+
+
+module.exports  = log;

package/src/utils/login.js

@@ -0,0 +1,69 @@
+'use strict';
+
+const cp = require('copy-paste');
+const log = require('./log.js');
+const finish = require('../utils/finish.js');
+
+
+/**
+ * Start the Login Process.
+ *
+ * This will save the logged in user to a configuration file.
+ * @private
+ */
+function login(callback) {
+  const config = require('./config.js');
+  let client = config.client;
+
+  log.info("Authorization Required:");
+
+  // Get the Auth URL
+  log.spinner.start('Getting Login URL...');
+  client.auth.getAuthUrl(function(err, url, frob) {
+    if ( err ) {
+      log.spinner.error('Could not get Login URL (' + err.msg + ')');
+      return finish();
+    }
+    log.spinner.stop();
+
+    // Copy URL to clipboard
+    cp.copy(url);
+
+    // Display the URL
+    log.style('Please open the following URL (');
+    log.style('copied to clipboard', 'bold.underline');
+    log.style(') and authorize RTM CLI:', true);
+    log.style(url, 'blue.underline', true);
+
+    // Wait for User Input
+    global._rl.question('Press [enter] when done: ', function() {
+      log.spinner.start('Logging In...');
+
+      // Get the Authorized User
+      client.auth.getAuthToken(frob, function(err, user) {
+        if ( err ) {
+          log.spinner.error('Could not Log In (' + err.msg + ')');
+          return finish();
+        }
+
+        // Display success
+        log.spinner.success('Logged in As: ' + user.username);
+
+        // Save the User to the config
+        config.saveUser(user);
+
+        // Return the User
+        if ( callback ) {
+          return callback(user);
+        }
+        else {
+          return finish();
+        }
+
+      });
+    });
+  });
+}
+
+
+module.exports = login;

package/src/utils/printIndicator.js

@@ -0,0 +1,43 @@
+'use strict';
+
+const config = require('./config.js');
+const log = require('./log.js');
+
+/**
+ * 
+ * @param {string} type note|url|recurring
+ * @param {object} task the task to print the indicator
+ * @param {string} style emoji|text
+ */
+function printIndicator(type,task) {
+    let styles = config.get().styles;
+    let iconType = config.get().iconType;
+
+    let indicatorStyle = task.isCompleted ? styles.completed : styles[type];
+    let notesIndicator,urlIndicator,recurringIndicator,subTaskIndicator;
+    iconType = iconType || 'text'; // defaults to text if nothing included
+    switch (iconType) {
+        case 'emoji':
+            notesIndicator = '📓';
+            urlIndicator = '🔗';
+            recurringIndicator = '🔁';
+            subTaskIndicator = '⤴️ '
+        break;
+        case 'text':  
+        default:
+            notesIndicator = '*';
+            urlIndicator = '+';
+            recurringIndicator = 'r';
+            subTaskIndicator = '(s) '
+        break;
+    }
+    let indicators = {
+        notes: notesIndicator,
+        url: urlIndicator,
+        recurring: recurringIndicator,
+        subtask: subTaskIndicator
+    }
+    log.style(indicators[type], indicatorStyle);
+}
+
+module.exports = printIndicator;

package/src/utils/prompt.js

@@ -0,0 +1,126 @@
+'use strict';
+
+const finish = require('./finish.js');
+const log = require('./log.js');
+const promptSync = require('prompt-sync')();
+
+/**
+ * Prompt the User for a set of answers
+ * @param {string} prompt One or more prompts to question the User
+ * @param {function} callback Callback function(answers)
+ * @deprecated Use indexPrompt
+ instead
+ */
+function prompt(prompt, callback) {
+
+  // Set callback
+  callback = arguments[arguments.length-1];
+
+  // Set prompts
+  let prompts = [];
+  for ( let i = 0; i < arguments.length-1; i++ ) {
+    prompts.push(arguments[i]);
+  }
+
+  // Start first prompt
+  log.style("[Enter a blank line when finished]", "dim", true);
+  _prompt(0, prompts, 0, [], callback);
+
+}
+
+
+/**
+ * Display the current prompt
+ * @param promptIndex Current prompt
+ * @param prompts Set of prompts
+ * @param answerIndex Current Answer
+ * @param answers Set of accumulated Answers
+ * @param callback Final Callback
+ * @private
+ */
+function _prompt(promptIndex, prompts, answerIndex, answers, callback) {
+  global._rl.question(prompts[promptIndex] + " ", function(answer) {
+
+    // Return with the answers
+    if ( promptIndex === 0 && answer === '' ) {
+      return _finish(answers, prompts.length, callback);
+    }
+
+    // Keep prompting
+    else {
+
+      // Set Answer
+      if ( !answers[answerIndex] ) {
+        answers[answerIndex] = [];
+      }
+      answers[answerIndex][promptIndex] = answer;
+
+      // Next Prompt
+      if ( promptIndex < prompts.length - 1 ) {
+        promptIndex++;
+        _prompt(promptIndex, prompts, answerIndex, answers, callback);
+      }
+
+      // Next Answer
+      else {
+        answerIndex++;
+        _prompt(0, prompts, answerIndex, answers, callback);
+      }
+
+    }
+
+  });
+
+}
+
+
+/**
+ * Remove any incomplete answers.  Then return to the final callback
+ * @param answers
+ * @param promptcount
+ * @param callback
+ * @private
+ */
+function _finish(answers, promptcount, callback) {
+  let rtn = [];
+  for ( let i = 0; i < answers.length; i++ ) {
+    let answer = answers[i];
+    if ( answer.length === promptcount ) {
+      rtn.push(answer);
+    }
+  }
+  if ( rtn.length === 0 ) {
+    return finish();
+  }
+  else {
+    return callback(rtn);
+  }
+}
+
+
+/**
+ * Prompts user for integer input until they enter a blank line
+ * @param {string} Prompt text to display
+ * @returns {number[]} array of user input integers
+ */
+ function indexPrompt(text) {
+  let tasks = []
+  let n
+  log.style('[Enter a blank line when finished]', 'dim', true);
+  while ( n != '' ) {
+      n = promptSync(text)
+      if (parseInt(n) ) {
+          tasks.push(n)
+       } else if (n == '') {
+          break
+       } else {
+          log.style('Enter a task index number, please.','red',true)
+       } 
+  }
+
+  return tasks
+
+}
+
+
+module.exports = {prompt,indexPrompt};

package/src/utils/sort.js

@@ -0,0 +1,283 @@
+'use strict';
+
+
+module.exports = {
+
+
+  // ==== LIST SORTING FUNCTIONS ==== //
+
+  lists: {
+
+    /**
+     * Sort the RTM Lists by the rtm-api added index field
+     * @param {RTMList} a RTM List a
+     * @param {RTMList} b RTM List b
+     * @returns {number}
+     */
+    index: function(a, b) {
+      return a.index - b.index;
+    },
+
+
+    /**
+     * Sort the RTM Lists by the RTM List id
+     * @param {RTMList} a RTM List a
+     * @param {RTMList} b RTM List b
+     * @returns {number}
+     */
+    id: function(a, b) {
+      return a.id - b.id;
+    },
+
+
+    /**
+     * Sort the RTM Lists by the RTM List name
+     * @param {RTMList} a RTM List a
+     * @param {RTMList} b RTM List b
+     * @returns {number}
+     */
+    name: function(a, b) {
+      if ( a.name.toLowerCase() < b.name.toLowerCase() ) {
+        return -1;
+      }
+      else if ( a.name.toLowerCase() > b.name.toLowerCase() ) {
+        return 1;
+      }
+      else {
+        return 0;
+      }
+    }
+
+  },
+
+
+  // ==== TASK SORTING FUNCTIONS ==== //
+
+  tasks: {
+
+    /**
+     * Sort Tasks by Index
+     * @param a
+     * @param b
+     * @returns {number}
+     */
+    index: function(a, b) {
+      return a.index - b.index;
+    },
+
+    /**
+     * Sort Tasks By Priority: 1,2,3,0
+     * @param a
+     * @param b
+     * @returns {number}
+     * @private
+     */
+    priority: function(a, b) {
+      let ap = a.priority === 0 ? 4 : a.priority;
+      let bp = b.priority === 0 ? 4 : b.priority;
+
+      return ap - bp;
+    },
+
+    /**
+     * Sort by Task Due Date (no due date first)
+     * @param a
+     * @param b
+     */
+    due: function(a, b) {
+      if ( a.due && !b.due ) {
+        return 1;
+      }
+      else if ( !a.due && b.due ) {
+        return -1;
+      }
+      else if ( a.due < b.due ) {
+        return -1;
+      }
+      else if ( a.due > b.due ) {
+        return 1;
+      }
+      else {
+        return 0;
+      }
+    },
+
+    /**
+     * Sort by Task Due Date (no due date last)
+     * @param a
+     * @param b
+     */
+    dueLast: function(a, b) {
+      if ( a.due && !b.due ) {
+        return -1;
+      }
+      else if ( !a.due && b.due ) {
+        return 1;
+      }
+      else if ( a.due < b.due ) {
+        return -1;
+      }
+      else if ( a.due > b.due ) {
+        return 1;
+      }
+      else {
+        return 0;
+      }
+    },
+
+    /**
+     * Sort by task completed status: uncompleted, completed
+     * @param a
+     * @param b
+     * @returns {number}
+     */
+    completed: function(a, b) {
+      if ( a.isCompleted && !b.isCompleted ) {
+        return 1;
+      }
+      else if ( !a.isCompleted && b.isCompleted ) {
+        return -1;
+      }
+      else {
+        return 0;
+      }
+    },
+
+    /**
+     * Sort Tasks By List Name (case insensitive)
+     * @param a
+     * @param b
+     * @returns {number}
+     * @private
+     */
+    listName: function(a, b) {
+      if ( a._list && b._list ) {
+        if ( a._list.name.toLowerCase() < b._list.name.toLowerCase() ) {
+          return -1;
+        }
+        else if ( a._list.name.toLowerCase() > b._list.name.toLowerCase() ) {
+          return 1;
+        }
+        else {
+          return 0;
+        }
+      }
+      return 0;
+    },
+
+    /**
+     * Sort Tasks for `ls` display (list name, priority)
+     * @param a
+     * @param b
+     * @returns {number}
+     * @private
+     */
+    ls: function(a, b) {
+      let sort = require(__filename);
+
+      // Sort by list
+      let list = sort.tasks.listName(a, b);
+      if ( list === 0 ) {
+
+        // Sort by completed status
+        let comp = sort.tasks.completed(a, b);
+        if ( comp === 0 ) {
+
+          // Sort by priority
+          let pri = sort.tasks.priority(a, b);
+          if ( pri === 0 ) {
+
+            // Sort by Due date
+            return sort.tasks.dueLast(a, b);
+
+          }
+          else {
+            return pri;
+          }
+
+        }
+        else {
+          return comp;
+        }
+      }
+      else {
+        return list;
+      }
+    },
+
+    /**
+     * Sort tasks for `lsd` display (due date, priority, list name)
+     * @param a
+     * @param b
+     * @returns {number}
+     * @private
+     */
+    lsd: function(a, b) {
+      let sort = require(__filename);
+
+      // Sort by Due Date
+      let due = sort.tasks.dueLast(a, b);
+      if ( due === 0 ) {
+
+        // Sort by Completed Status
+        let comp = sort.tasks.completed(a, b);
+        if ( comp === 0 ) {
+
+          // Sort By Priority
+          let pri = sort.tasks.priority(a, b);
+          if ( pri === 0 ) {
+
+            // Sort by List Name
+            return sort.tasks.listName(a, b);
+
+          }
+          else {
+            return pri;
+          }
+
+        }
+        else {
+          return comp;
+        }
+
+      }
+      else {
+        return due;
+      }
+    },
+
+    /**
+     * Sort tasks for `lsp` display (priority, due date)
+     * @param a
+     * @param b
+     * @returns {*}
+     */
+    lsp: function(a, b) {
+      let sort = require(__filename);
+
+      // Sort by Completed Status
+      let comp = sort.tasks.completed(a, b);
+      if ( comp === 0 ) {
+
+        // Sort by Priority
+        let pri = sort.tasks.priority(a, b);
+        if ( pri === 0 ) {
+
+          // Sort by Due Date
+          return sort.tasks.dueLast(a, b);
+
+        }
+        else {
+          return pri;
+        }
+
+      }
+      else {
+        return comp;
+      }
+
+    }
+
+  }
+
+};