automator.js

/* ========================================================================
 * Automator.js v0.1.1
 * A minimal JavaScript library for automating practically anything
 * in Javascript.
 *
 * Copyright (c) 2013 Matt Brophy (brophy.org)
 * https://github.com/brophdawg11/Automator.js
 *
 * Author: Matt Brophy
 * Website: http://www.brophy.org/
 *
 * Released under the MIT license
 * https://github.com/brophdawg11/Automator.js/blob/master/LICENSE
 * ------------------------------------------------------------------------ */
(function (root, factory) {
    if (typeof define === 'function' && define.amd) {

        define(factory);
    } else if (typeof exports === 'object') {

        module.exports = factory();
    } else {

        root.Automator = factory();
    }
}(this, function () {

    function isPromise(p) {
        return p &&
               typeof p.done === 'function' &&
               typeof p.fail === 'function' &&
               typeof p.always === 'function';
    }

    function isArray(a) {
        if ('isArray' in Array) {
            return Array.isArray(a);
        }

        return Object.prototype.toString.call(a) === '[object Array]';
    }

    function Automator(options) {

        var key,

            actions,

            interimActions,

            actionIdx,

            numIterations,

            iterationIdx,

            iterationCb,

            finalDfd,

            killed;

        options = typeof options === 'object' ? options : {};
        for (key in Automator.defaults) {
            if (typeof options[key] === 'undefined' || options[key === null]) {
                options[key] = Automator.defaults[key];
            }
        }

        function debug() {
            if (options.debug) {
                var args = Array.prototype.slice.call(arguments);
                args.unshift("Automator.js: ");
                console.log.apply(console, args);
            }
        }

        function resetState() {
            actions = [];
            interimActions = [];
            actionIdx = 0;
            numIterations = 1;
            iterationIdx = 0;
            finalDfd = new options.Deferred();
            killed = false;
        }

        function getDelayedFunction(func, delay) {
            if (typeof delay === 'number' && delay > 0) {
                debug('Sleeping for ' + delay + 'ms');
                return setTimeout.bind(null, func, delay);
            }
            return func;
        }

        function runAfterPromise(func, maybePromise) {
            if (isPromise(maybePromise)) {

                debug("Deferring next step until the promise is resolved");
                maybePromise.always(func);
            } else if (isArray(maybePromise)) {
                if (maybePromise.length > 0) {
                    debug("Received back an array of interim actions, " +
                          "running them now: ", maybePromise);
                    interimActions.unshift(maybePromise);
                }
                func();
            } else {
                debug("Passing value through to next step: ", maybePromise);
                func(maybePromise);
            }
        }

        function step(passThrough) {
            var nextAction, action, type, handler, retVal, delay, deferredStep;

            if (killed) {
                debug("was killed by user, exiting.");
                return;
            }

            if (actionIdx >= actions.length) {

                debug("iteration " + iterationIdx + " completed");

                if (typeof iterationCb === 'function') {
                    debug("Executing iteration callback");
                    retVal = iterationCb(iterationIdx);
                }

                if (++iterationIdx >= numIterations) {
                    debug("Done with iterations");
                    runAfterPromise(finalDfd.resolve, retVal);
                    return;
                }

                debug("Automator iteration " + iterationIdx + " ready to start");

                actionIdx = 0;

                deferredStep = getDelayedFunction(step, options.iterationDelay);

                runAfterPromise(deferredStep, retVal);

                return;
            }

            if (interimActions.length > 0) {

                action = interimActions[0].shift();

                if (interimActions[0].length === 0) {
                    interimActions.shift();
                }
            } else {

                action = actions[actionIdx++];
            }

            if (interimActions.length > 0) {

                nextAction = interimActions[0][0];
            } else {
                nextAction = actions[actionIdx];
            }

            if (action == null) {

                debug("Skipping null action");
                step();
                return;
            }

            debug('Handling action: ' + action);

            type = (typeof action);
            if      (type === 'number')   {
                handler = options.doNumber;
            } else if (type === 'string') {
                handler = options.doString;
            } else if (type === 'function') {
                handler = options.doFunction;
            } else {
                throw "Unsupported type!";
            }

            if (type === 'number' ||
                typeof nextAction === 'number' ||
                nextAction == null) {
                delay = 0;
            } else {
                delay = options.stepDelay;
            }

            deferredStep = getDelayedFunction(step, delay);

            retVal = handler.call(null, action, passThrough);
            runAfterPromise(deferredStep, retVal);
        }

        function expandActions(arr) {
            var expanded = [],
                action,
                matches,
                num,
                i = -1,
                len = arr.length;

            while (++i < len) {
                action = arr[i];
                if (typeof action === 'string') {

                    matches = action.match(/(.*)+x(\d+)$/);
                    if (matches && matches.length === 3) {
                        action = matches[1];
                        num = parseInt(matches[2], 10);

                        while (num-- > 0) { expanded.push(action); }
                        continue;
                    }
                }

                expanded.push(action);
            }

            return expanded;
        }

        this.automate = function (arr, num, cb) {

            num = (typeof num === 'number') ? num : 1;

            resetState();

            actions = expandActions(arr);

            numIterations = num;

            iterationCb = cb;

            step();

            return finalDfd.promise();
        };

        this.kill = function () {
            killed = true;
        };

    }

    Automator.keyCodeMap = {
        '0': 48,
        '1': 49,
        '2': 50,
        '3': 51,
        '4': 52,
        '5': 53,
        '6': 54,
        '7': 55,
        '8': 56,
        '9': 57,
        'a': 65,
        'b': 66,
        'c': 67,
        'd': 68,
        'e': 69,
        'f': 70,
        'g': 71,
        'h': 72,
        'i': 73,
        'j': 74,
        'k': 75,
        'l': 76,
        'm': 77,
        'n': 78,
        'o': 79,
        'p': 80,
        'q': 81,
        'r': 82,
        's': 83,
        't': 84,
        'u': 85,
        'v': 86,
        'w': 87,
        'x': 88,
        'y': 89,
        'z': 90,
        'left': 37,
        'up': 38,
        'right': 39,
        'down': 40,
        'enter': 13,
        'tab': 9,
        'ctrl': 17,
        'esc': 27,
        'space': 32
    };

    Automator.doNumber = function (n, passThrough) {
        var dfd = new Automator.MiniDeferred();
        setTimeout(dfd.resolve.bind(dfd, passThrough), n);
        return dfd.promise();
    };

    Automator.doFunction = function (func, passThrough) {
        return func.call(null, passThrough);
    };

    Automator.simulateKeyEvent = function (type, keyCode) {

        var eventObj = document.createEventObject ?
                       document.createEventObject() :
                       document.createEvent("Events");


        if (typeof eventObj.initEvent === 'function') {
            eventObj.initEvent("keydown", true, true);
        }

        eventObj.keyCode = keyCode;
        eventObj.which = keyCode;

        if (typeof document.dispatchEvent === 'function') {
            document.dispatchEvent(eventObj);
        } else {
            document.fireEvent("onkeydown", eventObj);
        }
    };

    Automator.doString = function (str, passThrough) {
        var keyCode = Automator.keyCodeMap[str];

        if (typeof keyCode !== 'number') { return; }

        return Automator.simulateKeyEvent("keydown", keyCode);
    };

    Automator.doObject = function (obj, passThrough) {};

    Automator.MiniDeferred = function MiniDeferred() {
      var callbacks = [],
          currentState = 0,
          currentArgs;

      function go() {
        var cb;
        while (callbacks.length > 0) {
          cb = callbacks.shift();
          if (cb.state === currentState) {
            cb.func.apply(this, currentArgs);
          }
        }
      }

      function addCallback(type, async, func) {
        if (typeof func === 'function') {
          var cb = { state: type, async: async, func: func };
          callbacks.push(cb);
          if (currentState !== 0) { go(); }
        }
        return this;
      }

      function changeState(s) {
        if (currentState !== 0) { return; }
        currentState = s;
        currentArgs = Array.prototype.slice.call(arguments, 1);
        go();
        return this;
      }

      this.resolve = changeState.bind(this, 1);
      this.reject = changeState.bind(this, 2);

      this.promise = function () {
        return {
          done: this.done.bind(this),
          fail: this.fail.bind(this),
          always: this.always.bind(this)
        };
      };

      this.done = addCallback.bind(this, 1, false);
      this.fail = addCallback.bind(this, 2, false);

      this.always = function (func) {
        this.done.call(this, func);
        this.fail.call(this, func);
        return this;
      };

      return this;
    };

    Automator.defaults = {
        debug: false,
        stepDelay: 0,
        iterationDelay: 0,
        Deferred: Automator.MiniDeferred,
        doNumber: Automator.doNumber,
        doFunction: Automator.doFunction,
        doString: Automator.doString,
        doObject: Automator.doObject
    };

    return Automator;

}));