mousetrapjs 0.1.2.2 → 0.1.3.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 695bbc0800be132445f64021f08b14450ed51408
+  data.tar.gz: d87c345754c3ecbff2005b5fcde86c66a690acf7
+SHA512:
+  metadata.gz: 60ac93071cd1eee948d5bde94115b2af5ce75cc4b0fcfebdd64555e726217b5106cd2f16cc65daa10624ccb10d451243530e94ba69764ae54c490d5cabd8d1f4
+  data.tar.gz: 43609f8b5a37550e9711c3f1f7d0554186b22efa0aa673f9e7cdaceefd2547c23c187f24c3ad299f3899d1f70c44275fcf588c5af739b87fd992d19e9f78f44b

data/lib/mousetrapjs/version.rb

@@ -1,3 +1,3 @@
 module Mousetrapjs
-  VERSION = "0.1.2.2"
+  VERSION = "0.1.3.2"
 end

data/vendor/assets/javascripts/mousetrap.js

@@ -1,5 +1,6 @@
+/*global define:false */
 /**
- * Copyright 2012 Craig Campbell
+ * Copyright 2013 Craig Campbell
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -16,7 +17,7 @@
  * Mousetrap is a simple keyboard shortcut library for Javascript with
  * no external dependencies
  *
- * @version 1.2.2
+ * @version 1.3.2
  * @url craig.is/killing/mice
  */
 (function() {
@@ -148,7 +149,7 @@
          *
          * @type {Object}
          */
-        _direct_map = {},
+        _directMap = {},
 
         /**
          * keeps track of what level each sequence is at since multiple
@@ -156,21 +157,21 @@
          *
          * @type {Object}
          */
-        _sequence_levels = {},
+        _sequenceLevels = {},
 
         /**
          * variable to store the setTimeout call
          *
          * @type {null|number}
          */
-        _reset_timer,
+        _resetTimer,
 
         /**
          * temporary state where we will ignore the next keyup
          *
          * @type {boolean|string}
          */
-        _ignore_next_keyup = false,
+        _ignoreNextKeyup = false,
 
         /**
          * are we currently inside of a sequence?
@@ -178,7 +179,7 @@
          *
          * @type {boolean|string}
          */
-        _sequence_type = false;
+        _sequenceType = false;
 
     /**
      * loop through the f keys, f1 to f19 and add them to the map
@@ -222,7 +223,22 @@
 
         // for keypress events we should return the character as is
         if (e.type == 'keypress') {
-            return String.fromCharCode(e.which);
+            var character = String.fromCharCode(e.which);
+
+            // if the shift key is not pressed then it is safe to assume
+            // that we want the character to be lowercase.  this means if
+            // you accidentally have caps lock on then your key bindings
+            // will continue to work
+            //
+            // the only side effect that might not be desired is if you
+            // bind something like 'A' cause you want to trigger an
+            // event when capital A is pressed caps lock will no longer
+            // trigger the event.  shift+a will though.
+            if (!e.shiftKey) {
+                character = character.toLowerCase();
+            }
+
+            return character;
         }
 
         // for non keypress events the special maps are needed
@@ -235,6 +251,10 @@
         }
 
         // if it is not in the special map
+
+        // with keydown and keyup events the character seems to always
+        // come in as an uppercase character whether you are pressing shift
+        // or not.  we should make sure it is always lowercase for comparisons
         return String.fromCharCode(e.which).toLowerCase();
     }
 
@@ -252,25 +272,25 @@
     /**
      * resets all sequence counters except for the ones passed in
      *
-     * @param {Object} do_not_reset
+     * @param {Object} doNotReset
      * @returns void
      */
-    function _resetSequences(do_not_reset, max_level) {
-        do_not_reset = do_not_reset || {};
+    function _resetSequences(doNotReset, maxLevel) {
+        doNotReset = doNotReset || {};
 
-        var active_sequences = false,
+        var activeSequences = false,
             key;
 
-        for (key in _sequence_levels) {
-            if (do_not_reset[key] && _sequence_levels[key] > max_level) {
-                active_sequences = true;
+        for (key in _sequenceLevels) {
+            if (doNotReset[key] && _sequenceLevels[key] > maxLevel) {
+                activeSequences = true;
                 continue;
             }
-            _sequence_levels[key] = 0;
+            _sequenceLevels[key] = 0;
         }
 
-        if (!active_sequences) {
-            _sequence_type = false;
+        if (!activeSequences) {
+            _sequenceType = false;
         }
     }
 
@@ -308,7 +328,7 @@
 
             // if this is a sequence but it is not at the right level
             // then move onto the next match
-            if (callback.seq && _sequence_levels[callback.seq] != callback.level) {
+            if (callback.seq && _sequenceLevels[callback.seq] != callback.level) {
                 continue;
             }
 
@@ -403,15 +423,16 @@
      * handles a character key event
      *
      * @param {string} character
+     * @param {Array} modifiers
      * @param {Event} e
      * @returns void
      */
-    function _handleCharacter(character, e) {
-        var callbacks = _getMatches(character, _eventModifiers(e), e),
+    function _handleKey(character, modifiers, e) {
+        var callbacks = _getMatches(character, modifiers, e),
             i,
-            do_not_reset = {},
-            max_level = 0,
-            processed_sequence_callback = false;
+            doNotReset = {},
+            maxLevel = 0,
+            processedSequenceCallback = false;
 
         // loop through matching callbacks for this key event
         for (i = 0; i < callbacks.length; ++i) {
@@ -422,21 +443,21 @@
             // callback for matching g cause otherwise you can only ever
             // match the first one
             if (callbacks[i].seq) {
-                processed_sequence_callback = true;
+                processedSequenceCallback = true;
 
                 // as we loop through keep track of the max
                 // any sequence at a lower level will be discarded
-                max_level = Math.max(max_level, callbacks[i].level);
+                maxLevel = Math.max(maxLevel, callbacks[i].level);
 
                 // keep a list of which sequences were matches for later
-                do_not_reset[callbacks[i].seq] = 1;
+                doNotReset[callbacks[i].seq] = 1;
                 _fireCallback(callbacks[i].callback, e, callbacks[i].combo);
                 continue;
             }
 
             // if there were no sequence matches but we are still here
             // that means this is a regular match so we should fire that
-            if (!processed_sequence_callback && !_sequence_type) {
+            if (!processedSequenceCallback && !_sequenceType) {
                 _fireCallback(callbacks[i].callback, e, callbacks[i].combo);
             }
         }
@@ -444,8 +465,8 @@
         // if you are inside of a sequence and the key you are pressing
         // is not a modifier key then we should reset all sequences
         // that were not matched by this key event
-        if (e.type == _sequence_type && !_isModifier(character)) {
-            _resetSequences(do_not_reset, max_level);
+        if (e.type == _sequenceType && !_isModifier(character)) {
+            _resetSequences(doNotReset, maxLevel);
         }
     }
 
@@ -455,7 +476,7 @@
      * @param {Event} e
      * @returns void
      */
-    function _handleKey(e) {
+    function _handleKeyEvent(e) {
 
         // normalize e.which for key events
         // @see http://stackoverflow.com/questions/4285627/javascript-keycode-vs-charcode-utter-confusion
@@ -470,12 +491,12 @@
             return;
         }
 
-        if (e.type == 'keyup' && _ignore_next_keyup == character) {
-            _ignore_next_keyup = false;
+        if (e.type == 'keyup' && _ignoreNextKeyup == character) {
+            _ignoreNextKeyup = false;
             return;
         }
 
-        _handleCharacter(character, e);
+        Mousetrap.handleKey(character, _eventModifiers(e), e);
     }
 
     /**
@@ -497,8 +518,8 @@
      * @returns void
      */
     function _resetSequenceTimer() {
-        clearTimeout(_reset_timer);
-        _reset_timer = setTimeout(_resetSequences, 1000);
+        clearTimeout(_resetTimer);
+        _resetTimer = setTimeout(_resetSequences, 1000);
     }
 
     /**
@@ -563,7 +584,7 @@
 
         // start off by adding a sequence level record for this combination
         // and setting the level to 0
-        _sequence_levels[combo] = 0;
+        _sequenceLevels[combo] = 0;
 
         // if there is no action pick the best one for the first key
         // in the sequence
@@ -578,9 +599,9 @@
          * @param {Event} e
          * @returns void
          */
-        var _increaseSequence = function(e) {
-                _sequence_type = action;
-                ++_sequence_levels[combo];
+        var _increaseSequence = function() {
+                _sequenceType = action;
+                ++_sequenceLevels[combo];
                 _resetSequenceTimer();
             },
 
@@ -598,7 +619,7 @@
                 // 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') {
-                    _ignore_next_keyup = _characterFromEvent(e);
+                    _ignoreNextKeyup = _characterFromEvent(e);
                 }
 
                 // weird race condition if a sequence ends with the key
@@ -621,11 +642,14 @@
      * @param {string} combination
      * @param {Function} callback
      * @param {string=} action
-     * @param {string=} sequence_name - name of sequence if part of sequence
+     * @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, sequence_name, level) {
+    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, ' ');
@@ -680,7 +704,7 @@
         }
 
         // remove an existing match if there is one
-        _getMatches(key, modifiers, {type: action}, !sequence_name, combination);
+        _getMatches(key, modifiers, {type: action}, !sequenceName, combination);
 
         // add this call back to the array
         // if it is a sequence put it at the beginning
@@ -688,11 +712,11 @@
         //
         // this is important because the way these are processed expects
         // the sequence ones to come first
-        _callbacks[key][sequence_name ? 'unshift' : 'push']({
+        _callbacks[key][sequenceName ? 'unshift' : 'push']({
             callback: callback,
             modifiers: modifiers,
             action: action,
-            seq: sequence_name,
+            seq: sequenceName,
             level: level,
             combo: combination
         });
@@ -713,9 +737,9 @@
     }
 
     // start!
-    _addEvent(document, 'keypress', _handleKey);
-    _addEvent(document, 'keydown', _handleKey);
-    _addEvent(document, 'keyup', _handleKey);
+    _addEvent(document, 'keypress', _handleKeyEvent);
+    _addEvent(document, 'keydown', _handleKeyEvent);
+    _addEvent(document, 'keyup', _handleKeyEvent);
 
     var Mousetrap = {
 
@@ -734,8 +758,8 @@
          * @returns void
          */
         bind: function(keys, callback, action) {
-            _bindMultiple(keys instanceof Array ? keys : [keys], callback, action);
-            _direct_map[keys + ':' + action] = callback;
+            keys = keys instanceof Array ? keys : [keys];
+            _bindMultiple(keys, callback, action);
             return this;
         },
 
@@ -744,24 +768,20 @@
          *
          * the unbinding sets the callback function of the specified key combo
          * to an empty function and deletes the corresponding key in the
-         * _direct_map dict.
-         *
-         * the keycombo+action has to be exactly the same as
-         * it was defined in the bind method
+         * _directMap dict.
          *
          * TODO: actually remove this from the _callbacks dictionary instead
          * of binding an empty function
          *
+         * the keycombo+action has to be exactly the same as
+         * it was defined in the bind method
+         *
          * @param {string|Array} keys
          * @param {string} action
          * @returns void
          */
         unbind: function(keys, action) {
-            if (_direct_map[keys + ':' + action]) {
-                delete _direct_map[keys + ':' + action];
-                this.bind(keys, function() {}, action);
-            }
-            return this;
+            return Mousetrap.bind(keys, function() {}, action);
         },
 
         /**
@@ -772,7 +792,9 @@
          * @returns void
          */
         trigger: function(keys, action) {
-            _direct_map[keys + ':' + action]();
+            if (_directMap[keys + ':' + action]) {
+                _directMap[keys + ':' + action]({}, keys);
+            }
             return this;
         },
 
@@ -785,7 +807,7 @@
          */
         reset: function() {
             _callbacks = {};
-            _direct_map = {};
+            _directMap = {};
             return this;
         },
 
@@ -796,7 +818,7 @@
         * @param {Element} element
         * @return {boolean}
         */
-        stopCallback: function(e, element, combo) {
+        stopCallback: function(e, element) {
 
             // if the element has the class "mousetrap" then no need to stop
             if ((' ' + element.className + ' ').indexOf(' mousetrap ') > -1) {
@@ -805,7 +827,12 @@
 
             // stop for input, select, and textarea
             return element.tagName == 'INPUT' || element.tagName == 'SELECT' || element.tagName == 'TEXTAREA' || (element.contentEditable && element.contentEditable == 'true');
-        }
+        },
+
+        /**
+         * exposes _handleKey publicly so it can be overwritten by extensions
+         */
+        handleKey: _handleKey
     };
 
     // expose mousetrap to the global object

metadata

@@ -1,15 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mousetrapjs
 version: !ruby/object:Gem::Version
-  version: 0.1.2.2
-  prerelease: 
+  version: 0.1.3.2
 platform: ruby
 authors:
 - Luiz Eduardo Kowalski
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-12-16 00:00:00.000000000 Z
+date: 2013-04-12 00:00:00.000000000 Z
 dependencies: []
 description: Gem for Mousetrap, a simple library for handling keyboard shortcuts in
   Javascript
@@ -30,26 +29,25 @@ files:
 - vendor/assets/javascripts/mousetrap.js
 homepage: https://github.com/luizkowalski/mousetrapjs
 licenses: []
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.23
+rubygems_version: 2.0.0
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: Mousetrap is a simple library for handling keyboard shortcuts in Javascript
 test_files: []