mousetrap-rails 0.0.12 → 1.4.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d7c1c1518dc3723ad152da8bdbeb6731a807f5e7
-  data.tar.gz: b109201e9f8dab37a40a1eb2d05bc140625d1e4d
+  metadata.gz: 504385d122d04d11a10a3f30d00ae2c185f694df
+  data.tar.gz: c4bcc42500168cc81ffa7eca59dd3f96dbd95265
 SHA512:
-  metadata.gz: d87bdda376611d3a0c9a0cc48affa09fd1f41e94fbfba42c2643f322a5274177d49aa7053e09b50ce7ab0e39679ea9d1517429ec799252e5e6bc07da7dc71149
-  data.tar.gz: 0a41c7856d6e1c9d280f36dfd8f80cd9e18cb82e8c8e3d08a2d4a516a1ad6cbb8d4e528ffac3dfc136681c87bfc3e1e7bbd3bd3b9b3756e4e8f37063c9978c22
+  metadata.gz: 1fa0dcfe2a6c3c80ccb1d25ee2ba3558d390633101eb8d6872da0853332c8f3143a68ca6c7fe8c8f91e6ec71b86137b679fabee80f3827dcaba623b9f31f15a7
+  data.tar.gz: 7819598758d59a895f34f28e470e5cbef65ee4c13418a15a12c0a257bb2f9fa93dbe712d3600910834c6155bdf2dac7d88393c86d903e667040bd46b59895085

data/.travis.yml

@@ -3,4 +3,8 @@ rvm:
   - 1.9.2
   - 1.9.3
   - 2.0.0
-  - rbx-19mode
+  - rbx-2.0.0
+  - rbx-2.1.0
+  - rbx-2.1.1
+  - rbx-2.2.0
+  - rbx-2.2.1

data/CHANGELOG.md

@@ -1,6 +1,10 @@
 ## v0.0.13.wip
 
-* [] Add moustrap extensions generator
+* update mousetrap.js to 1.4.6
+* update readme
+* add rubinius versions in travis-ci config
+* add mousetrap/plugins
+* add mousetrap:update:plugins raketask
 
 ## v0.0.12
 

data/README.md

@@ -5,7 +5,6 @@
 
 The `mousetrap-rails` gem integrates Mousetrap javascript library with Rails asset pipeline.
 
-
 ## Installation
 
 ### Add mousetrap-rails gem to app
@@ -37,6 +36,18 @@ It will create a sample `keybindings.js.coffee` file in `app/assets/javascripts`
 
 Voila!
 
+Also you can use mousetrap plugins. Require them in your `application.js` file
+
+```javascript
+//= require mousetrap/plugins       # To require all plugins
+//= require mousetrap/dictionary    # To require dictionary plugin
+//= require mousetrap/global        # To require global plugin
+//= require mousetrap/pause         # To require pause plugin
+//= require mousetrap/record        # To require record plugin
+```
+
+See plugin descriptions below.
+
 ### Latest (may be unstable) version
 
 Instead of `gem 'mousetrap-rails'` add to your Gemfile
@@ -45,6 +56,8 @@ Instead of `gem 'mousetrap-rails'` add to your Gemfile
 gem 'mousetrap-rails', github: 'kugaevsky/mousetrap-rails'
 ```
 
+`Mousetrap-rails` versioning use `mousetrap.js` library version number.
+
 ## Usage
 
 ### Via data-attributes
@@ -59,7 +72,7 @@ You can add keyboard navigation to your links by using `data-keybinding` attribu
 You can jump to an input
 
 ```haml
-= text_field_tag 'Username', nil, data: { keybinding: 'u' }     # Press 'u' to focus username input field
+= text_field_tag 'Username', nil, data: { keybinding: 'u' }         # Press 'u' to focus username input field
 ```
 
 ### Via javascript
@@ -67,7 +80,7 @@ You can jump to an input
 Any javascript function can be called with mousetrap
 
 ```coffeescript
-Mousetrap.bind 'f', (e) -> alert 'My perfect function called'   # Press 'f' to popup alert
+Mousetrap.bind 'f', (e) -> alert 'My perfect function called'       # Press 'f' to popup alert
 ```
 
 ### More examples (from official guide)
@@ -100,18 +113,84 @@ You can find full documentation on [Mousetrap library page](http://craig.is/kill
 
 You can display key binding hints near links with `data-keybinding` attribute by pressing `Alt+Shift+h`. Now it's just experimental feature for debugging purposes only.
 
-## TODO
+## Plugins
+
+### Global Bindings
+
+    //= require mousetrap/global        # ---> application.js
+
+This extension allows you to specify keyboard events that will work anywhere including inside textarea/input fields.
+
+```coffeescript
+Mousetrap.bindGlobal 'ctrl+s', -> _save()
+```
+
+This means that a keyboard event bound using `Mousetrap.bind` will only work outside of form input fields, but using `Moustrap.bindGlobal` will work in both places.
+
+
+### Bind dictionary
+
+    //= require mousetrap/dictionary        # ---> application.js
+
+This extension overwrites the default bind behavior and allows you to bind multiple combinations in a single bind call.
+
+Usage looks like:
+
+```coffeescript
+Mousetrap.bind
+    'a': -> console.log('a')
+    'b': -> console.log('b')
+```
+
+You can optionally pass in `keypress`, `keydown` or `keyup` as a second argument.
+
+Other bind calls work the same way as they do by default.
+
+
+### Pause/unpause
+
+    //= require mousetrap/pause             # ---> application.js
+
+This extension allows Mousetrap to be paused and unpaused without having to reset keyboard shortcuts and rebind them.
+
+```coffeescript
+# stop Mousetrap events from firing
+Mousetrap.pause()
+
+# allow Mousetrap events to fire again
+Mousetrap.unpause()
+```
+
+
+### Record
+
+    //= require mousetrap/record              # ---> application.js
+
+This extension lets you use Mousetrap to record keyboard sequences and play them back:
+
+```slim
+button onclick="recordSequence()" Record
+```
+
+```coffeescript
+recordSequence = () ->
+  Mousetrap.record (sequence) ->
+    # sequence is an array like ['ctrl+k', 'c']
+    alert('You pressed: ' + sequence.join(' '))
+````
 
-- [ ] Add moustrap extensions generator
+[More detailed plugins description](http://craig.is/killing/mice#extensions)
 
 ## Contributing
 
 Please submit all pull requests against latest `*.wip` branch. If your pull request contains new features, you **must** include relevant tests.
 
-You can easily update mousetrap.js library via rake task.
+You can easily update mousetrap.js library via rake tasks.
 
 ```bash
-$ rake mousetrap:update
+$ rake mousetrap:update          # Update main mousetrap javascript lib and its plugins
+$ rake mousetrap:update:main     # Update main mousetrap javascript lib
+$ rake mousetrap:update:plugins  # Update mousetrap javascript lib plugins
 ```
 
 Thanks in advance!

data/Rakefile

@@ -4,14 +4,43 @@ require 'rspec/core/rake_task'
 RSpec::Core::RakeTask.new(:spec)
 task :default => :spec
 
+ORIGIN_URL  = "https://raw.github.com/ccampbell/mousetrap/master"
+BASE_FILE_PATH   = "vendor/assets/javascripts"
+
 namespace :mousetrap do
-  desc "Update Mousetrap javascript library from https://raw.github.com/ccampbell/mousetrap/master/mousetrap.js"
+  desc "Update main mousetrap javascript lib and its plugins"
   task :update do
-    ORIGIN_URL  = "https://raw.github.com/ccampbell/mousetrap/master/mousetrap.js"
-    FILE_PATH   = "vendor/assets/javascripts/mousetrap.js"
-    puts "Updating Mousetrap.js library from origin"
-    puts "#{ORIGIN_URL} -> #{FILE_PATH}\n\n"
-    system 'wget', ORIGIN_URL, "-O", FILE_PATH
-    puts "Mousetrap.js updated!"
+    %w(main plugins).each do |task|
+      Rake::Task["mousetrap:update:#{task}"].invoke
+    end
+  end
+
+  namespace :update do
+    desc "Update main mousetrap javascript lib"
+    task :main do
+      origin_url  = "#{ORIGIN_URL}/mousetrap.js"
+      file_path   = "#{BASE_FILE_PATH}/mousetrap.js"
+      download origin_url, file_path
+      puts "\033[32m-> Main mousetrap lib updated!\033[0m\n\n"
+    end
+
+    desc "Update mousetrap javascript lib plugins"
+    task :plugins do
+      plugins = { dictionary: 'plugins/bind-dictionary/mousetrap-bind-dictionary.js',
+                  global:     'plugins/global-bind/mousetrap-global-bind.js',
+                  pause:      'plugins/pause/mousetrap-pause.js',
+                  record:     'plugins/record/mousetrap-record.js'
+                  }
+      plugins.each_pair do |name, file|
+        origin_url  = "#{ORIGIN_URL}/#{file}"
+        file_path   = "#{BASE_FILE_PATH}/mousetrap/#{name}.js"
+        download origin_url, file_path
+        puts "\033[32m-> #{name} mousetrap plugin updated!\033[0m\n\n"
+      end
+    end
   end
 end
+
+def download(source, dest)
+  system 'wget', source, "-O", dest
+end

data/lib/mousetrap-rails/version.rb

@@ -1,5 +1,5 @@
 module Mousetrap
   module Rails
-    VERSION = "0.0.12"
+    VERSION = "1.4.6"
   end
 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.5
+ * @version 1.4.6
  * @url craig.is/killing/mice
  */
 (function(window, document, undefined) {
@@ -402,6 +402,36 @@
         return modifiers;
     }
 
+    /**
+     * prevents default for this event
+     *
+     * @param {Event} e
+     * @returns void
+     */
+    function _preventDefault(e) {
+        if (e.preventDefault) {
+            e.preventDefault();
+            return;
+        }
+
+        e.returnValue = false;
+    }
+
+    /**
+     * stops propogation for this event
+     *
+     * @param {Event} e
+     * @returns void
+     */
+    function _stopPropagation(e) {
+        if (e.stopPropagation) {
+            e.stopPropagation();
+            return;
+        }
+
+        e.cancelBubble = true;
+    }
+
     /**
      * actually calls the callback function
      *
@@ -412,24 +442,16 @@
      * @param {Event} e
      * @returns void
      */
-    function _fireCallback(callback, e, combo) {
+    function _fireCallback(callback, e, combo, sequence) {
 
         // if this event should not happen stop here
-        if (Mousetrap.stopCallback(e, e.target || e.srcElement, combo)) {
+        if (Mousetrap.stopCallback(e, e.target || e.srcElement, combo, sequence)) {
             return;
         }
 
         if (callback(e, combo) === false) {
-            if (e.preventDefault) {
-                e.preventDefault();
-            }
-
-            if (e.stopPropagation) {
-                e.stopPropagation();
-            }
-
-            e.returnValue = false;
-            e.cancelBubble = true;
+            _preventDefault(e);
+            _stopPropagation(e);
         }
     }
 
@@ -481,7 +503,7 @@
 
                 // keep a list of which sequences were matches for later
                 doNotReset[callbacks[i].seq] = 1;
-                _fireCallback(callbacks[i].callback, e, callbacks[i].combo);
+                _fireCallback(callbacks[i].callback, e, callbacks[i].combo, callbacks[i].seq);
                 continue;
             }
 

data/vendor/assets/javascripts/mousetrap/dictionary.js

@@ -0,0 +1,39 @@
+/**
+ * Overwrites default Mousetrap.bind method to optionally accept
+ * an object to bind multiple key events in a single call
+ *
+ * You can pass it in like:
+ *
+ * Mousetrap.bind({
+ *     'a': function() { console.log('a'); },
+ *     'b': function() { console.log('b'); }
+ * });
+ *
+ * And can optionally pass in 'keypress', 'keydown', or 'keyup'
+ * as a second argument
+ *
+ */
+/* global Mousetrap:true */
+Mousetrap = (function(Mousetrap) {
+    var self = Mousetrap,
+        _oldBind = self.bind,
+        args;
+
+    self.bind = function() {
+        args = arguments;
+
+        // normal call
+        if (typeof args[0] == 'string' || args[0] instanceof Array) {
+            return _oldBind(args[0], args[1], args[2]);
+        }
+
+        // object passed in
+        for (var key in args[0]) {
+            if (args[0].hasOwnProperty(key)) {
+                _oldBind(key, args[0][key], args[1]);
+            }
+        }
+    };
+
+    return self;
+}) (Mousetrap);

data/vendor/assets/javascripts/mousetrap/global.js

@@ -0,0 +1,36 @@
+/**
+ * adds a bindGlobal method to Mousetrap that allows you to
+ * bind specific keyboard shortcuts that will still work
+ * inside a text input field
+ *
+ * usage:
+ * Mousetrap.bindGlobal('ctrl+s', _saveChanges);
+ */
+/* global Mousetrap:true */
+Mousetrap = (function(Mousetrap) {
+    var _globalCallbacks = {},
+        _originalStopCallback = Mousetrap.stopCallback;
+
+    Mousetrap.stopCallback = function(e, element, combo, sequence) {
+        if (_globalCallbacks[combo] || _globalCallbacks[sequence]) {
+            return false;
+        }
+
+        return _originalStopCallback(e, element, combo);
+    };
+
+    Mousetrap.bindGlobal = function(keys, callback, action) {
+        Mousetrap.bind(keys, callback, action);
+
+        if (keys instanceof Array) {
+            for (var i = 0; i < keys.length; i++) {
+                _globalCallbacks[keys[i]] = true;
+            }
+            return;
+        }
+
+        _globalCallbacks[keys] = true;
+    };
+
+    return Mousetrap;
+}) (Mousetrap);

data/vendor/assets/javascripts/mousetrap/pause.js

@@ -0,0 +1,29 @@
+/**
+ * adds a pause and unpause method to Mousetrap
+ * this allows you to enable or disable keyboard shortcuts
+ * without having to reset Mousetrap and rebind everything
+ */
+/* global Mousetrap:true */
+Mousetrap = (function(Mousetrap) {
+    var self = Mousetrap,
+        _originalStopCallback = self.stopCallback,
+        enabled = true;
+
+    self.stopCallback = function(e, element, combo) {
+        if (!enabled) {
+            return true;
+        }
+
+        return _originalStopCallback(e, element, combo);
+    };
+
+    self.pause = function() {
+        enabled = false;
+    };
+
+    self.unpause = function() {
+        enabled = true;
+    };
+
+    return self;
+}) (Mousetrap);

data/vendor/assets/javascripts/mousetrap/plugins.js

@@ -0,0 +1,4 @@
+//= require mousetrap/dictionary
+//= require mousetrap/global
+//= require mousetrap/pause
+//= require mousetrap/record

data/vendor/assets/javascripts/mousetrap/record.js

@@ -0,0 +1,189 @@
+/**
+ * This extension allows you to record a sequence using Mousetrap.
+ *
+ * @author Dan Tao <daniel.tao@gmail.com>
+ */
+(function(Mousetrap) {
+    /**
+     * the sequence currently being recorded
+     *
+     * @type {Array}
+     */
+    var _recordedSequence = [],
+
+        /**
+         * a callback to invoke after recording a sequence
+         *
+         * @type {Function|null}
+         */
+        _recordedSequenceCallback = null,
+
+        /**
+         * a list of all of the keys currently held down
+         *
+         * @type {Array}
+         */
+        _currentRecordedKeys = [],
+
+        /**
+         * temporary state where we remember if we've already captured a
+         * character key in the current combo
+         *
+         * @type {boolean}
+         */
+        _recordedCharacterKey = false,
+
+        /**
+         * a handle for the timer of the current recording
+         *
+         * @type {null|number}
+         */
+        _recordTimer = null,
+
+        /**
+         * the original handleKey method to override when Mousetrap.record() is
+         * called
+         *
+         * @type {Function}
+         */
+        _origHandleKey = Mousetrap.handleKey;
+
+    /**
+     * handles a character key event
+     *
+     * @param {string} character
+     * @param {Array} modifiers
+     * @param {Event} e
+     * @returns void
+     */
+    function _handleKey(character, modifiers, e) {
+        // remember this character if we're currently recording a sequence
+        if (e.type == 'keydown') {
+            if (character.length === 1 && _recordedCharacterKey) {
+                _recordCurrentCombo();
+            }
+
+            for (i = 0; i < modifiers.length; ++i) {
+                _recordKey(modifiers[i]);
+            }
+            _recordKey(character);
+
+        // once a key is released, all keys that were held down at the time
+        // count as a keypress
+        } else if (e.type == 'keyup' && _currentRecordedKeys.length > 0) {
+            _recordCurrentCombo();
+        }
+    }
+
+    /**
+     * marks a character key as held down while recording a sequence
+     *
+     * @param {string} key
+     * @returns void
+     */
+    function _recordKey(key) {
+        var i;
+
+        // one-off implementation of Array.indexOf, since IE6-9 don't support it
+        for (i = 0; i < _currentRecordedKeys.length; ++i) {
+            if (_currentRecordedKeys[i] === key) {
+                return;
+            }
+        }
+
+        _currentRecordedKeys.push(key);
+
+        if (key.length === 1) {
+            _recordedCharacterKey = true;
+        }
+    }
+
+    /**
+     * marks whatever key combination that's been recorded so far as finished
+     * and gets ready for the next combo
+     *
+     * @returns void
+     */
+    function _recordCurrentCombo() {
+        _recordedSequence.push(_currentRecordedKeys);
+        _currentRecordedKeys = [];
+        _recordedCharacterKey = false;
+        _restartRecordTimer();
+    }
+
+    /**
+     * ensures each combo in a sequence is in a predictable order and formats
+     * key combos to be '+'-delimited
+     *
+     * modifies the sequence in-place
+     *
+     * @param {Array} sequence
+     * @returns void
+     */
+    function _normalizeSequence(sequence) {
+        var i;
+
+        for (i = 0; i < sequence.length; ++i) {
+            sequence[i].sort(function(x, y) {
+                // modifier keys always come first, in alphabetical order
+                if (x.length > 1 && y.length === 1) {
+                    return -1;
+                } else if (x.length === 1 && y.length > 1) {
+                    return 1;
+                }
+
+                // character keys come next (list should contain no duplicates,
+                // so no need for equality check)
+                return x > y ? 1 : -1;
+            });
+
+            sequence[i] = sequence[i].join('+');
+        }
+    }
+
+    /**
+     * finishes the current recording, passes the recorded sequence to the stored
+     * callback, and sets Mousetrap.handleKey back to its original function
+     *
+     * @returns void
+     */
+    function _finishRecording() {
+        if (_recordedSequenceCallback) {
+            _normalizeSequence(_recordedSequence);
+            _recordedSequenceCallback(_recordedSequence);
+        }
+
+        // reset all recorded state
+        _recordedSequence = [];
+        _recordedSequenceCallback = null;
+        _currentRecordedKeys = [];
+
+        Mousetrap.handleKey = _origHandleKey;
+    }
+
+    /**
+     * called to set a 1 second timeout on the current recording
+     *
+     * this is so after each key press in the sequence the recording will wait for
+     * 1 more second before executing the callback
+     *
+     * @returns void
+     */
+    function _restartRecordTimer() {
+        clearTimeout(_recordTimer);
+        _recordTimer = setTimeout(_finishRecording, 1000);
+    }
+
+    /**
+     * records the next sequence and passes it to a callback once it's
+     * completed
+     *
+     * @param {Function} callback
+     * @returns void
+     */
+    Mousetrap.record = function(callback) {
+        Mousetrap.handleKey = _handleKey;
+        _recordedSequenceCallback = callback;
+    };
+
+})(Mousetrap);

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: mousetrap-rails
 version: !ruby/object:Gem::Version
-  version: 0.0.12
+  version: 1.4.6
 platform: ruby
 authors:
 - Nick Kugaevsky
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain:
 - gem-public_cert.pem
-date: 2013-09-15 00:00:00.000000000 Z
+date: 2013-11-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -161,6 +161,11 @@ files:
 - spec/generators/install_generator_spec.rb
 - spec/spec_helper.rb
 - vendor/assets/javascripts/mousetrap.js
+- vendor/assets/javascripts/mousetrap/dictionary.js
+- vendor/assets/javascripts/mousetrap/global.js
+- vendor/assets/javascripts/mousetrap/pause.js
+- vendor/assets/javascripts/mousetrap/plugins.js
+- vendor/assets/javascripts/mousetrap/record.js
 homepage: http://kugaevsky.github.com/mousetrap-rails
 licenses:
 - MIT
@@ -184,7 +189,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.0.3
+rubygems_version: 2.1.11
 signing_key: 
 specification_version: 4
 summary: Integrate Mousetrap javascript library with Rails Asset Pipeline