mousetrapjs 1.4.0 → 1.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8e244036ef071e3d6222f608a02a948661138a11
-  data.tar.gz: a1ca76a8c83b8df9cce0ab86d3538591dd4c5e56
+  metadata.gz: a05b6045de34fc7a0ad351cfbde3c00199238455
+  data.tar.gz: 8c923714b26069877b456fffbfd66b5fbefa4485
 SHA512:
-  metadata.gz: d09f19f0fbb6d71efc1cfe9a324bec24a7ece344d05f948770fb19c1b370deaab8899cf257595dbdde6161ae560546b3b602ef2a7f884ded80eda41a0b914da9
-  data.tar.gz: 117a6788596f94ab0513fbfb12a61699abd52ddf62acf5189d0f59cd38ee5fec6e99edd79b5de8b05b1d106faff6f40b493dc88f01584dc76cf38042e7597706
+  metadata.gz: 1c147ad6eeb0ab7b660fdaa2ff6d968ef4245f3bad8fda3f0281221bb3cb44e13ca21f4585869a3e02d98ed582c34d5325d8cdde16801d17383f52be4f89cf7e
+  data.tar.gz: d3a340ed7919ea2731f88493e229a6815ac0ae8b861e6a087870377d39ff52a9fa49b64c5fdb207e9c0fb66fffb961e6ae7688d614f3d9cdb8d2cc2466c7622e

data/Gemfile

@@ -1,4 +1,3 @@
 source 'https://rubygems.org'
 
-# Specify your gem's dependencies in mousetrapjs.gemspec
 gemspec

data/lib/mousetrapjs/version.rb

@@ -1,3 +1,3 @@
 module Mousetrapjs
-  VERSION = "1.4.0"
+  VERSION = "1.4.1"
 end

data/vendor/assets/javascripts/mousetrap.js

@@ -17,7 +17,7 @@
  * Mousetrap is a simple keyboard shortcut library for Javascript with
  * no external dependencies
  *
- * @version 1.4.0
+ * @version 1.4.1
  * @url craig.is/killing/mice
  */
 (function() {
@@ -180,7 +180,7 @@
          *
          * @type {boolean|string}
          */
-        _sequenceType = false;
+        _nextExpectedAction = false;
 
     /**
      * loop through the f keys, f1 to f19 and add them to the map
@@ -291,7 +291,7 @@
         }
 
         if (!activeSequences) {
-            _sequenceType = false;
+            _nextExpectedAction = false;
         }
     }
 
@@ -302,11 +302,12 @@
      * @param {string} character
      * @param {Array} modifiers
      * @param {Event|Object} e
-     * @param {boolean=} remove - should we remove any matches
+     * @param {string=} sequenceName - name of the sequence we are looking for
      * @param {string=} combination
+     * @param {number=} level
      * @returns {Array}
      */
-    function _getMatches(character, modifiers, e, remove, combination) {
+    function _getMatches(character, modifiers, e, sequenceName, combination, level) {
         var i,
             callback,
             matches = [],
@@ -327,9 +328,9 @@
         for (i = 0; i < _callbacks[character].length; ++i) {
             callback = _callbacks[character][i];
 
-            // if this is a sequence but it is not at the right level
-            // then move onto the next match
-            if (callback.seq && _sequenceLevels[callback.seq] != callback.level) {
+            // if a sequence name is not specified, but this is a sequence at
+            // the wrong level then move onto the next match
+            if (!sequenceName && callback.seq && _sequenceLevels[callback.seq] != callback.level) {
                 continue;
             }
 
@@ -348,9 +349,14 @@
             // firefox will fire a keypress if meta or control is down
             if ((action == 'keypress' && !e.metaKey && !e.ctrlKey) || _modifiersMatch(modifiers, callback.modifiers)) {
 
-                // remove is used so if you change your mind and call bind a
-                // second time with a new function the first one is overwritten
-                if (remove && callback.combo == combination) {
+                // when you bind a combination or sequence a second time it
+                // should overwrite the first one.  if a sequenceName or
+                // combination is specified in this call it does just that
+                //
+                // @todo make deleting its own method?
+                var deleteCombo = !sequenceName && callback.combo == combination;
+                var deleteSequence = sequenceName && callback.seq == sequenceName && callback.level == level;
+                if (deleteCombo || deleteSequence) {
                     _callbacks[character].splice(i, 1);
                 }
 
@@ -490,7 +496,7 @@
         // modifier keys are ignored because you can have a sequence
         // that contains modifiers such as "enter ctrl+space" and in most
         // cases the modifier key will be pressed before the next key
-        if (e.type == _sequenceType && !_isModifier(character)) {
+        if (e.type == _nextExpectedAction && !_isModifier(character)) {
             _resetSequences(doNotReset);
         }
     }
@@ -611,90 +617,89 @@
         // and setting the level to 0
         _sequenceLevels[combo] = 0;
 
-        // if there is no action pick the best one for the first key
-        // in the sequence
-        if (!action) {
-            action = _pickBestAction(keys[0], []);
-        }
-
         /**
          * callback to increase the sequence level for this sequence and reset
          * all other sequences that were active
          *
-         * @param {Event} e
-         * @returns void
+         * @param {string} nextAction
+         * @returns {Function}
          */
-        var _increaseSequence = function() {
-                _sequenceType = action;
+        function _increaseSequence(nextAction) {
+            return function() {
+                _nextExpectedAction = nextAction;
                 ++_sequenceLevels[combo];
                 _resetSequenceTimer();
-            },
-
-            /**
-             * wraps the specified callback inside of another function in order
-             * to reset all sequence counters as soon as this sequence is done
-             *
-             * @param {Event} e
-             * @returns void
-             */
-            _callbackAndReset = function(e) {
-                _fireCallback(callback, e, combo);
-
-                // we should ignore the next key up if the action is key down
-                // or keypress.  this is so if you finish a sequence and
-                // release the key the final key will not trigger a keyup
-                if (action !== 'keyup') {
-                    _ignoreNextKeyup = _characterFromEvent(e);
-                }
+            };
+        }
+
+        /**
+         * wraps the specified callback inside of another function in order
+         * to reset all sequence counters as soon as this sequence is done
+         *
+         * @param {Event} e
+         * @returns void
+         */
+        function _callbackAndReset(e) {
+            _fireCallback(callback, e, combo);
+
+            // we should ignore the next key up if the action is key down
+            // or keypress.  this is so if you finish a sequence and
+            // release the key the final key will not trigger a keyup
+            if (action !== 'keyup') {
+                _ignoreNextKeyup = _characterFromEvent(e);
+            }
 
-                // weird race condition if a sequence ends with the key
-                // another sequence begins with
-                setTimeout(_resetSequences, 10);
-            },
-            i;
+            // weird race condition if a sequence ends with the key
+            // another sequence begins with
+            setTimeout(_resetSequences, 10);
+        }
 
         // loop through keys one at a time and bind the appropriate callback
         // function.  for any key leading up to the final one it should
         // increase the sequence. after the final, it should reset all sequences
-        for (i = 0; i < keys.length; ++i) {
-            _bindSingle(keys[i], i < keys.length - 1 ? _increaseSequence : _callbackAndReset, action, combo, i);
+        //
+        // if an action is specified in the original bind call then that will
+        // be used throughout.  otherwise we will pass the action that the
+        // next key in the sequence should match.  this allows a sequence
+        // to mix and match keypress and keydown events depending on which
+        // ones are better suited to the key provided
+        for (var i = 0; i < keys.length; ++i) {
+            var isFinal = i + 1 === keys.length;
+            var wrappedCallback = isFinal ? _callbackAndReset : _increaseSequence(action || _getKeyInfo(keys[i + 1]).action);
+            _bindSingle(keys[i], wrappedCallback, action, combo, i);
         }
     }
 
     /**
-     * binds a single keyboard combination
+     * Converts from a string key combination to an array
      *
-     * @param {string} combination
-     * @param {Function} callback
-     * @param {string=} action
-     * @param {string=} sequenceName - name of sequence if part of sequence
-     * @param {number=} level - what part of the sequence the command is
-     * @returns void
+     * @param  {string} combination like "command+shift+l"
+     * @return {Array}
      */
-    function _bindSingle(combination, callback, action, sequenceName, level) {
-
-        // store a direct mapped reference for use with Mousetrap.trigger
-        _directMap[combination + ':' + action] = callback;
+    function _keysFromString(combination) {
+        if (combination === '+') {
+            return ['+'];
+        }
 
-        // make sure multiple spaces in a row become a single space
-        combination = combination.replace(/\s+/g, ' ');
+        return combination.split('+');
+    }
 
-        var sequence = combination.split(' '),
-            i,
+    /**
+     * Gets info for a specific key combination
+     *
+     * @param  {string} combination key combination ("command+s" or "a" or "*")
+     * @param  {string=} action
+     * @returns {Object}
+     */
+    function _getKeyInfo(combination, action) {
+        var keys,
             key,
-            keys,
+            i,
             modifiers = [];
 
-        // if this pattern is a sequence of keys then run through this method
-        // to reprocess each pattern one key at a time
-        if (sequence.length > 1) {
-            _bindSequence(combination, sequence, callback, action);
-            return;
-        }
-
         // take the keys from this pattern and figure out what the actual
         // pattern is all about
-        keys = combination === '+' ? ['+'] : combination.split('+');
+        keys = _keysFromString(combination);
 
         for (i = 0; i < keys.length; ++i) {
             key = keys[i];
@@ -722,14 +727,49 @@
         // we will try to pick the best event for it
         action = _pickBestAction(key, modifiers, action);
 
+        return {
+            key: key,
+            modifiers: modifiers,
+            action: action
+        };
+    }
+
+    /**
+     * binds a single keyboard combination
+     *
+     * @param {string} combination
+     * @param {Function} callback
+     * @param {string=} action
+     * @param {string=} sequenceName - name of sequence if part of sequence
+     * @param {number=} level - what part of the sequence the command is
+     * @returns void
+     */
+    function _bindSingle(combination, callback, action, sequenceName, level) {
+
+        // store a direct mapped reference for use with Mousetrap.trigger
+        _directMap[combination + ':' + action] = callback;
+
+        // make sure multiple spaces in a row become a single space
+        combination = combination.replace(/\s+/g, ' ');
+
+        var sequence = combination.split(' '),
+            info;
+
+        // if this pattern is a sequence of keys then run through this method
+        // to reprocess each pattern one key at a time
+        if (sequence.length > 1) {
+            _bindSequence(combination, sequence, callback, action);
+            return;
+        }
+
+        info = _getKeyInfo(combination, action);
+
         // make sure to initialize array if this is the first time
         // a callback is added for this key
-        if (!_callbacks[key]) {
-            _callbacks[key] = [];
-        }
+        _callbacks[info.key] = _callbacks[info.key] || [];
 
         // remove an existing match if there is one
-        _getMatches(key, modifiers, {type: action}, !sequenceName, combination);
+        _getMatches(info.key, info.modifiers, {type: info.action}, sequenceName, combination, level);
 
         // add this call back to the array
         // if it is a sequence put it at the beginning
@@ -737,10 +777,10 @@
         //
         // this is important because the way these are processed expects
         // the sequence ones to come first
-        _callbacks[key][sequenceName ? 'unshift' : 'push']({
+        _callbacks[info.key][sequenceName ? 'unshift' : 'push']({
             callback: callback,
-            modifiers: modifiers,
-            action: action,
+            modifiers: info.modifiers,
+            action: info.action,
             seq: sequenceName,
             level: level,
             combo: combination

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mousetrapjs
 version: !ruby/object:Gem::Version
-  version: 1.4.0
+  version: 1.4.1
 platform: ruby
 authors:
 - Luiz Eduardo Kowalski
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-05-20 00:00:00.000000000 Z
+date: 2013-06-17 00:00:00.000000000 Z
 dependencies: []
 description: Gem for Mousetrap, a simple library for handling keyboard shortcuts in
   Javascript