atlas_assets 0.6.4 → 0.6.5

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    NDlkMmM2MTRhZmY5ZmI0YjIzZGEyZjQ2Yjg1NWY0MWVmODc4MmI5ZQ==
+    M2IwZDJhMzk4NjE2MDI2MDg5MzBkNTFhMmU4YWJhNGM2OTcwNzc1OA==
   data.tar.gz: !binary |-
-    Mzg3ZjM1YTQxMDc2ZGMzMTcxMDRiNmRkMWQxNjE2YWI4OGE1NmI4OA==
+    MmEwZmZhMDlkOTcwNDZkOTBkM2ExNGQ0ZDZiYTlkOTNlZTNiMDBiZQ==
 SHA512:
   metadata.gz: !binary |-
-    ZDFhOGI0ZWY3MjkwYzRkNTA4MDJmN2FiODVmZGFiMDExYTVhZDk0NjkyNzdh
-    NWU0ZjVlYWJkMGVmZTU4NjJiMmYxNGY2MWFmNGJkYjQ2ZmZkNzg4YTJjODk3
-    NjY3NTMxNThhOWRjMjcyNDdlYjczODY4OGYwZDRmZGY0ZmRiNmU=
+    ZWQxMTQyMTdmYzQ2NjJhNGU0Nzk2OGRhN2E0MjdlYjdiZmRiMDc1Y2FhMWVl
+    ZGM2ZGQ2ODI5YjA5Y2E3ZjhhYzVjNmRiZDMyYmYxMzdiNmFhN2NhNDRmYTk2
+    ZmEzMjZiMjQ0OTlhYzNiNTE3NzgyMmU4YWNkMzJiYzM4MWUwZTU=
   data.tar.gz: !binary |-
-    YzY4ZjA4Yjk1NmFiN2I2ZDM1YTZlNDYwMjJkOTEzNTdhY2U3YTFlMDdlOGNm
-    Mjc3MTdiNzgyM2Y1NjIwNDg2ODUyZGIyMmYxMmM1NTRkMzYzMGRkNWYxOWQ5
-    MTk5ZDA2NzY3ZDNmMjYyMTRhYzBiYjMxODlhNzE4MmY2ZDVlNDU=
+    MGUxNGI5ZWRkZDQ3NDE3Njk3NTU4ZTFmNjUyNjdjYjM2MTk0MzdkODJhZTFh
+    ZjNkMjE4MWMxMjZkYTI0Y2YxOTJlYzNlYTNmOWRiZTRmOTFkMDAxNGYwMjky
+    ZTk2YjQ4YmJmODdhNDM0ZTBhMWY1YmRkY2ZiODc5MjEyNTlhMWM=

data/Gemfile.lock

@@ -9,7 +9,7 @@ GIT
 PATH
   remote: .
   specs:
-    atlas_assets (0.6.3)
+    atlas_assets (0.6.5)
       handlebars_assets (~> 0.12.2)
 
 GEM
@@ -61,7 +61,7 @@ GEM
     rack-rewrite (1.3.3)
     rake (10.0.4)
     safe_yaml (0.7.1)
-    sass (3.2.17)
+    sass (3.2.18)
     sprockets (2.12.0)
       hike (~> 1.2)
       multi_json (~> 1.0)

data/docs/_posts/2014-04-03-keypress.md

@@ -0,0 +1,34 @@
+---
+layout: default
+title:  "Keypress"
+---
+
+Keypress
+======
+
+
+Keypress is a robust keyboard input capturing Javascript utility focused on input for games. For details and documentation, please visit [http://dmauro.github.io/Keypress/](http://dmauro.github.io/Keypress/).
+
+## Simple Example
+
+<p><button class='btn btn-info' id='shift-s'>Hellooooooo, press shift+s to slideToggle me</button></p>
+
+~~~js
+  var listener = new window.keypress.Listener()
+  listener.simple_combo("shift s", function() {
+    console.log("You pressed shift and s");
+    $('#shift-s').slideToggle()
+  })
+~~~
+
+<script>
+$(function () {
+  var listener = new window.keypress.Listener()
+  listener.simple_combo("shift s", function() {
+    console.log("You pressed shift and s");
+    $('#shift-s').slideToggle()
+  })
+
+})
+</script>
+

data/lib/assets/javascripts/libraries/keypress.coffee

@@ -0,0 +1,872 @@
+###
+Copyright 2014 David Mauro
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+
+Keypress is a robust keyboard input capturing Javascript utility
+focused on input for games.
+
+version 2.0.1
+###
+
+###
+Combo options available and their defaults:
+    keys            : []            - An array of the keys pressed together to activate combo.
+    count           : 0             - The number of times a counting combo has been pressed. Reset on release.
+    is_unordered    : false         - Unless this is set to true, the keys can be pressed down in any order.
+    is_counting     : false         - Makes this a counting combo (see documentation).
+    is_exclusive    : false         - This combo will replace other exclusive combos when true.
+    is_solitary     : false         - This combo will only fire if ONLY it's keys are pressed down.
+    is_sequence     : false         - Rather than a key combo, this is an ordered key sequence.
+    prevent_default : false         - Prevent default behavior for all component key keypresses.
+    prevent_repeat  : false         - Prevent the combo from repeating when keydown is held.
+    on_keydown      : null          - A function that is called when the combo is pressed.
+    on_keyup        : null          - A function that is called when the combo is released.
+    on_release      : null          - A function that is called when all keys in the combo are released.
+    this            : undefined     - Defines the scope for your callback functions.
+###
+
+###########
+# Constants
+###########
+
+_factory_defaults =
+    is_unordered    : false
+    is_counting     : false
+    is_exclusive    : false
+    is_solitary     : false
+    prevent_default : false
+    prevent_repeat  : false
+
+_modifier_keys = ["meta", "alt", "option", "ctrl", "shift", "cmd"]
+
+_metakey = "ctrl"
+
+###########################
+# Public object and Classes
+###########################
+
+window.keypress = {}
+
+keypress.debug = false
+
+class Combo
+    constructor: (dictionary) ->
+        # Copy over any non-false values
+        for own property, value of dictionary
+            @[property] = value if value != false
+
+        # Standard Defaults
+        @keys = @keys or []
+        @count = @count or 0
+
+    allows_key_repeat: ->
+        # Combos with keydown functions should be able to rapid fire
+        # when holding down the key for an extended period
+        return not @prevent_repeat and typeof @on_keydown is "function"
+
+    reset: ->
+        @count = 0
+        @keyup_fired = null
+
+class keypress.Listener
+    constructor:(element, defaults) ->
+        # Public properties
+        @should_suppress_event_defaults = false
+        @should_force_event_defaults = false
+        @sequence_delay = 800
+
+        # Private properties
+        @_registered_combos = []
+        @_keys_down = []
+        @_active_combos = []
+        @_sequence = []
+        @_sequence_timer = null
+        @_prevent_capture = false
+        @_defaults = defaults or {}
+        for own property, value of _factory_defaults
+            @_defaults[property] = @_defaults[property] or value
+
+        # Attach handlers to element
+        element = element or document.body
+
+        attach_handler = (target, event, handler) ->
+            if target.addEventListener
+                target.addEventListener event, handler
+            else if target.attachEvent
+                target.attachEvent "on#{event}", handler
+
+        attach_handler element, "keydown", (e) =>
+            e = e or window.event
+            @_receive_input e, true
+            @_bug_catcher e
+        attach_handler element, "keyup", (e) =>
+            e = e or window.event
+            @_receive_input e, false
+        attach_handler window, "blur", =>
+            # Assume all keys are released when we can't catch key events
+            # This prevents alt+tab conflicts
+            for key in @_keys_down
+                @_key_up key, {}
+            @_keys_down = []
+
+    # Helper Methods
+
+    _bug_catcher: (e) ->
+        # This seems to be Mac specific weirdness, so we'll target "cmd" as metaKey
+        # Force a keyup for non-modifier keys when command is held because they don't fire
+        if _metakey is "cmd" and "cmd" in @_keys_down and _convert_key_to_readable(e.keyCode) not in ["cmd", "shift", "alt", "caps", "tab"]
+            @_receive_input e, false
+        # Note: we're currently ignoring the fact that this doesn't catch the bug that a keyup
+        # will not fire if you keydown a combo, then press and hold cmd, then keyup the combo.
+        # Perhaps we should fire keyup on all active combos when we press cmd?
+
+    _cmd_bug_check: (combo_keys) ->
+        # We don't want to allow combos to activate if the cmd key
+        # is pressed, but cmd isn't in them. This is so they don't
+        # accidentally rapid fire due to our hack-around for the cmd
+        # key bug and having to fake keyups.
+        if _metakey is "cmd" and "cmd" in @_keys_down and "cmd" not in combo_keys
+            return false
+        return true
+
+    _prevent_default: (e, should_prevent) ->
+        # If we've pressed a combo, or if we are working towards
+        # one, we should prevent the default keydown event.
+        if (should_prevent or @should_suppress_event_defaults) and not @should_force_event_defaults
+            if e.preventDefault then e.preventDefault() else e.returnValue = false
+            e.stopPropagation() if e.stopPropagation
+
+    # Tracking Combos
+
+    _get_active_combos: (key) ->
+        # Based on the keys_down and the key just pressed or released
+        # (which should not be in keys_down), we determine if any
+        # combo in registered_combos could be considered active.
+        # This will return an array of active combos
+
+        active_combos = []
+
+        # First check that every key in keys_down maps to a combo
+        keys_down = _filter_array @_keys_down, (down_key) ->
+            down_key isnt key
+        keys_down.push key
+
+        # Get perfect matches
+        @_match_combo_arrays keys_down, (match) =>
+            active_combos.push(match) if @_cmd_bug_check match.keys
+
+        # Get fuzzy matches
+        @_fuzzy_match_combo_arrays keys_down, (match) =>
+            return if match in active_combos
+            active_combos.push(match) unless match.is_solitary or not @_cmd_bug_check match.keys
+
+        return active_combos
+
+    _get_potential_combos: (key) ->
+        # Check if we are working towards pressing a combo.
+        # Used for preventing default on keys that might match
+        # to a combo in the future.
+        potentials = []
+        for combo in @_registered_combos
+            continue if combo.is_sequence
+            potentials.push(combo) if key in combo.keys and @_cmd_bug_check combo.keys
+        return potentials
+
+    _add_to_active_combos: (combo) ->
+        should_replace = false
+        should_prepend = true
+        already_replaced = false
+        # An active combo is any combo which the user has already entered.
+        # We use this to track when a user has released the last key of a
+        # combo for on_release, and to keep combos from 'overlapping'.
+        if combo in @_active_combos
+            return true
+        else if @_active_combos.length
+            # We have to check if we're replacing another active combo
+            # So compare the combo.keys to all active combos' keys.
+            for i in [0...@_active_combos.length]
+                active_combo = @_active_combos[i]
+                continue unless active_combo and active_combo.is_exclusive and combo.is_exclusive
+                active_keys = active_combo.keys
+                unless should_replace
+                    for active_key in active_keys
+                        should_replace = true
+                        unless active_key in combo.keys
+                            should_replace = false
+                            break
+
+                if should_prepend and not should_replace
+                    for combo_key in combo.keys
+                        should_prepend = false
+                        unless combo_key in active_keys
+                            should_prepend = true
+                            break
+
+                if should_replace
+                    if already_replaced
+                        active_combo = @_active_combos.splice(i, 1)[0]
+                        active_combo.reset() if active_combo?
+                    else
+                        active_combo =  @_active_combos.splice(i, 1, combo)[0]
+                        active_combo.reset() if active_combo?
+                        already_replaced = true
+                    should_prepend = false
+        if should_prepend
+            @_active_combos.unshift combo
+
+        return should_replace or should_prepend
+
+    _remove_from_active_combos: (combo) ->
+        for i in [0...@_active_combos.length]
+            active_combo = @_active_combos[i]
+            if active_combo is combo
+                combo = @_active_combos.splice(i, 1)[0]
+                combo.reset()
+                break
+        return
+
+    # Sequence Methods
+
+    _get_possible_sequences: ->
+        # Determine what if any sequences we're working towards.
+        # We will consider any which any part of the end of the sequence
+        # matches and return all of them.
+        matches = []
+        for combo in @_registered_combos
+            for j in [1..@_sequence.length]
+                sequence = @_sequence.slice -j
+                continue unless combo.is_sequence
+                unless "shift" in combo.keys
+                    sequence = _filter_array sequence, (key) ->
+                        return key isnt "shift"
+                    continue unless sequence.length
+                for i in [0...sequence.length]
+                    if combo.keys[i] is sequence[i]
+                        match = true
+                    else
+                        match = false
+                        break
+                matches.push(combo) if match
+        return matches
+
+    _add_key_to_sequence: (key, e) ->
+        @_sequence.push key
+        # Now check if they're working towards a sequence
+        sequence_combos = @_get_possible_sequences()
+        if sequence_combos.length
+            for combo in sequence_combos
+                @_prevent_default e, combo.prevent_default
+            # If we're working towards one, give them more time to keep going
+            clearTimeout(@_sequence_timer) if @_sequence_timer
+            if @sequence_delay > -1
+                @_sequence_timer = setTimeout ->
+                    @_sequence = []
+                , @sequence_delay
+        else
+            # If we're not working towards something, just clear it out
+            @_sequence = []
+        return
+
+    _get_sequence: (key) ->
+        # Compare _sequence to all combos
+        for combo in @_registered_combos
+            continue unless combo.is_sequence
+            for j in [1..@_sequence.length]
+                # As we are traversing backwards through the sequence keys,
+                # Take out any shift keys, unless shift is in the combo.
+                sequence = (_filter_array @_sequence, (seq_key) ->
+                    return true if "shift" in combo.keys
+                    return seq_key isnt "shift"
+                ).slice -j
+                continue unless combo.keys.length is sequence.length
+                for i in [0...sequence.length]
+                    seq_key = sequence[i]
+                    # Special case for shift. Ignore shift keys, unless the sequence explicitly uses them
+                    continue if seq_key is "shift" unless "shift" in combo.keys
+                    # Don't select this combo if we're pressing shift and shift isn't in it
+                    continue if key is "shift" and "shift" not in combo.keys
+                    if combo.keys[i] is seq_key
+                        match = true
+                    else
+                        match = false
+                        break
+            return combo if match
+        return false
+
+    # Catching Combos
+
+    _receive_input: (e, is_keydown) ->
+        # If we're not capturing input, we should
+        # clear out _keys_down for good measure
+        if @_prevent_capture
+            @_keys_down = [] if @_keys_down.length
+            return
+        key = _convert_key_to_readable e.keyCode
+        # Catch tabbing out of a non-capturing state
+        if !is_keydown and !@_keys_down.length and key in ["alt", _metakey]
+            return
+        return unless key
+        if is_keydown
+            @_key_down key, e
+        else
+            @_key_up key, e
+
+    _fire: (event, combo, key_event, is_autorepeat) ->
+        # Only fire this event if the function is defined
+        if typeof combo["on_" + event] is "function"
+            @_prevent_default key_event, (combo["on_" + event].call(combo.this, key_event, combo.count, is_autorepeat) isnt true)
+        # We need to mark that keyup has already happened
+        if event is "release"
+            combo.count = 0
+        if event is "keyup"
+            combo.keyup_fired = true
+
+    _match_combo_arrays: (potential_match, match_handler) ->
+        # This will return all combos that match
+        for source_combo in @_registered_combos
+            if (not source_combo.is_unordered and _compare_arrays_sorted(potential_match, source_combo.keys)) or (source_combo.is_unordered and _compare_arrays(potential_match, source_combo.keys))
+                match_handler source_combo
+        return
+
+    _fuzzy_match_combo_arrays: (potential_match, match_handler) ->
+        # This will return combos that match even if other keys are pressed
+        for source_combo in @_registered_combos
+            if (not source_combo.is_unordered and _is_array_in_array_sorted(source_combo.keys, potential_match)) or (source_combo.is_unordered and _is_array_in_array(source_combo.keys, potential_match))
+                match_handler source_combo
+        return
+
+    _keys_remain: (combo) ->
+        for key in combo.keys
+            if key in @_keys_down
+                keys_remain = true
+                break
+        return keys_remain
+
+    _key_down: (key, e) ->
+        # Check if we're holding shift
+        shifted_key = _convert_to_shifted_key key, e
+        key = shifted_key if shifted_key
+
+        # Add the key to sequences
+        @_add_key_to_sequence key, e
+        sequence_combo = @_get_sequence key
+        @_fire("keydown", sequence_combo, e) if sequence_combo
+
+        # We might have modifier keys down when coming back to
+        # this window and they might not be in _keys_down, so
+        # we're doing a check to make sure we put it back in.
+        # This only works for explicit modifier keys.
+        for mod, event_mod of _modifier_event_mapping
+            continue unless e[event_mod]
+            continue if mod is key or mod in @_keys_down
+            @_keys_down.push mod
+        # Alternatively, we might not have modifier keys down
+        # that we think are, so we should catch those too
+        for mod, event_mod of _modifier_event_mapping
+            continue if mod is key
+            if mod in @_keys_down and not e[event_mod]
+                # The Windows key will think it is the cmd key, but won't trigger the event mod
+                continue if mod is "cmd" and _metakey isnt "cmd"
+                for i in [0...@_keys_down.length]
+                    @_keys_down.splice(i, 1) if @_keys_down[i] is mod
+
+        # Find which combos we have pressed or might be working towards, and prevent default
+        combos = @_get_active_combos key
+        potential_combos = @_get_potential_combos key
+        for combo in combos
+            @_handle_combo_down combo, potential_combos, key, e
+        if potential_combos.length
+            for potential in potential_combos
+                @_prevent_default e, potential.prevent_default
+
+        if key not in @_keys_down
+            @_keys_down.push key
+        return
+
+    _handle_combo_down: (combo, potential_combos, key, e) ->
+        # Make sure we're not trying to fire for a combo that already fired
+        return false unless key in combo.keys
+
+        @_prevent_default e, (combo and combo.prevent_default)
+
+        is_autorepeat = false
+        # If we've already pressed this key, check that we want to fire
+        # again, otherwise just add it to the keys_down list.
+        if key in @_keys_down
+            is_autorepeat = true
+            return false unless combo.allows_key_repeat()
+
+        # Now we add this combo or replace it in _active_combos
+        result = @_add_to_active_combos combo, key
+
+        # We reset the keyup_fired property because you should be
+        # able to fire that again, if you've pressed the key down again
+        combo.keyup_fired = false
+
+        # Now we fire the keydown event unless there is a larger exclusive potential combo
+        is_other_exclusive = false
+        if combo.is_exclusive
+            for potential_combo in potential_combos
+                if potential_combo.is_exclusive and potential_combo.keys.length > combo.keys.length
+                    is_other_exclusive = true
+                    break
+
+        unless is_other_exclusive
+            if combo.is_counting and typeof combo.on_keydown is "function"
+                combo.count += 1
+
+            # Only fire keydown if we added it
+            if result
+                @_fire "keydown", combo, e, is_autorepeat
+
+    _key_up: (key, e) ->
+        # Check if we're holding shift
+        unshifted_key = key
+        shifted_key = _convert_to_shifted_key key, e
+        key = shifted_key if shifted_key
+        shifted_key = _keycode_shifted_keys[unshifted_key]
+        # We have to make sure the key matches to what we had in _keys_down
+        if e.shiftKey
+            key = unshifted_key unless shifted_key and shifted_key in @_keys_down
+        else
+            key = shifted_key unless unshifted_key and unshifted_key in @_keys_down
+
+        # Check if we have a keyup firing
+        sequence_combo = @_get_sequence key
+        @_fire("keyup", sequence_combo, e) if sequence_combo
+
+        # Remove from the list
+        return false unless key in @_keys_down
+        for i in [0...@_keys_down.length]
+            if @_keys_down[i] in [key, shifted_key, unshifted_key]
+                @_keys_down.splice i, 1
+                break
+
+        # Store this for later cleanup
+        active_combos_length = @_active_combos.length
+
+        # When releasing we should only check if we
+        # match from _active_combos so that we don't
+        # accidentally fire for a combo that was a
+        # smaller part of the one we actually wanted.
+        combos = []
+        for active_combo in @_active_combos
+            if key in active_combo.keys
+                combos.push active_combo
+        for combo in combos
+            @_handle_combo_up combo, e, key
+
+        # We also need to check other combos that might still be in active_combos
+        # and needs to be removed from it.
+        if active_combos_length > 1
+            for active_combo in @_active_combos
+                continue if active_combo is undefined or active_combo in combos
+                unless @_keys_remain active_combo
+                    @_remove_from_active_combos active_combo
+        return
+
+    _handle_combo_up: (combo, e, key) ->
+        @_prevent_default e, (combo and combo.prevent_default)
+
+        # Check if any keys from this combo are still being held.
+        keys_remaining = @_keys_remain combo
+
+        # Any unactivated combos will fire
+        if !combo.keyup_fired
+            # And we should not fire it if it is a solitary combo and something else is pressed
+            keys_down = @_keys_down.slice()
+            keys_down.push key
+            if not combo.is_solitary or _compare_arrays keys_down, combo.keys
+                @_fire "keyup", combo, e
+                # Dont' add to the count unless we only have a keyup callback
+                if combo.is_counting and typeof combo.on_keyup is "function" and typeof combo.on_keydown isnt "function"
+                    combo.count += 1
+
+        # If this was the last key released of the combo, clean up.
+        unless keys_remaining
+            @_fire "release", combo, e
+            @_remove_from_active_combos combo
+        return
+
+    # Public Registration Methods
+
+    simple_combo: (keys, callback) ->
+        # Shortcut for simple combos.
+        @register_combo(
+            keys            : keys
+            on_keydown      : callback
+        )
+
+    counting_combo: (keys, count_callback) ->
+        # Shortcut for counting combos
+        @register_combo(
+            keys            : keys
+            is_counting     : true
+            is_unordered    : false
+            on_keydown      : count_callback
+        )
+
+    sequence_combo: (keys, callback) ->
+        @register_combo(
+            keys            : keys
+            on_keydown      : callback
+            is_sequence     : true
+        )
+
+    register_combo: (combo_dictionary) ->
+        # Allow a space dilineated string instead of array
+        if typeof combo_dictionary["keys"] is "string"
+            combo_dictionary["keys"] = combo_dictionary["keys"].split " "
+        for own property, value of @_defaults
+            if combo_dictionary[property] == undefined
+                combo_dictionary[property] = value
+        combo = new Combo combo_dictionary
+
+        if _validate_combo combo
+            @_registered_combos.push combo
+            return combo
+
+    register_many: (combo_array) ->
+        # Will return an array of the combos actually registered
+        @register_combo(combo) for combo in combo_array
+
+    unregister_combo: (keys_or_combo) ->
+        return false unless keys_or_combo
+
+        unregister_combo = (combo) =>
+            for i in [0...@_registered_combos.length]
+                if combo is @_registered_combos[i]
+                    @_registered_combos.splice i, 1
+                    break
+
+        if keys_or_combo.keys
+            unregister_combo keys_or_combo
+        else
+            for combo in @_registered_combos
+                continue unless combo
+            if typeof keys_or_combo is "string"
+                keys_or_combo = keys_or_combo.split " "
+            if (combo.is_unordered and _compare_arrays(keys_or_combo, combo.keys)) or (not combo.is_unordered and _compare_arrays_sorted(keys_or_combo, combo.keys))
+                    unregister_combo combo
+
+    unregister_many: (combo_array) ->
+        for combo in combo_array
+            @unregister_combo combo
+
+    # Other public methods
+
+    get_registered_combos: ->
+        return @_registered_combos
+
+    reset: ->
+        @_registered_combos = []
+
+    listen: ->
+        @_prevent_capture = false
+
+    stop_listening: ->
+        @_prevent_capture = true
+
+    get_meta_key: ->
+        # Helpful for debugging purposes
+        return _metakey
+
+##################
+# Helper Functions
+##################
+
+_decide_meta_key = ->
+    # If the useragent reports Mac OS X, assume cmd is metakey
+    if navigator.userAgent.indexOf("Mac OS X") != -1
+        _metakey = "cmd"
+    return
+
+_change_keycodes_by_browser = ->
+    if navigator.userAgent.indexOf("Opera") != -1
+        # Opera does weird stuff with command and control keys, let's fix that.
+        # Note: Opera cannot override meta + s browser default of save page.
+        # Note: Opera does some really strange stuff when cmd+alt+shift
+        # are held and a non-modifier key is pressed.
+        _keycode_dictionary["17"] = "cmd"
+    return
+
+_convert_key_to_readable = (k) ->
+    return _keycode_dictionary[k]
+
+_filter_array = (array, callback) ->
+  if array.filter
+    return array.filter(callback)
+  else
+    # For browsers without Array.prototype.filter like IE<9:
+    return (element for element in array when callback(element))
+
+_compare_arrays = (a1, a2) ->
+    # This will ignore the ordering of the arrays
+    # and simply check if they have the same contents.
+    return false unless a1.length is a2.length
+    for item in a1
+        continue if item in a2
+        return false
+    return true
+
+_compare_arrays_sorted = (a1, a2) ->
+    return false unless a1.length is a2.length
+    for i in [0...a1.length]
+        return false unless a1[i] is a2[i]
+    return true
+
+_is_array_in_array = (a1, a2) ->
+    # Returns true only if all of the contents of
+    # a1 are included in a2
+    for item in a1
+        return false unless item in a2
+    return true
+
+_is_array_in_array_sorted = (a1, a2) ->
+    # Return true only if all of the contents of
+    # a1 are include in a2 and they appear in the
+    # same order in both.
+    prev = 0
+    for item in a1
+        index = a2.indexOf item
+        if index >= prev
+            prev = index
+        else
+            return false
+    return true
+
+_log_error = () ->
+    console.log arguments... if keypress.debug
+
+_key_is_valid = (key) ->
+    valid = false
+    for _, valid_key of _keycode_dictionary
+        if key is valid_key
+            valid = true
+            break
+    unless valid
+        for _, valid_key of _keycode_shifted_keys
+            if key is valid_key
+                valid = true
+                break
+    return valid
+
+_validate_combo = (combo) ->
+    validated = true
+
+    # Warn for lack of keys
+    unless combo.keys.length
+        _log_error "You're trying to bind a combo with no keys:", combo
+
+    # Convert "meta" to either "ctrl" or "cmd"
+    # Don't explicity use the command key, it breaks
+    # because it is the windows key in Windows, and
+    # cannot be hijacked.
+    for i in [0...combo.keys.length]
+        key = combo.keys[i]
+        # Check the name and replace if needed
+        alt_name = _keycode_alternate_names[key]
+        key = combo.keys[i] = alt_name if alt_name
+        if key is "meta"
+            combo.keys.splice i, 1, _metakey
+        if key is "cmd"
+            _log_error "Warning: use the \"meta\" key rather than \"cmd\" for Windows compatibility"
+
+    # Check that all keys in the combo are valid
+    for key in combo.keys
+        unless _key_is_valid key
+            _log_error "Do not recognize the key \"#{key}\""
+            validated = false
+
+    # We can only allow a single non-modifier key
+    # in combos that include the command key (this
+    # includes 'meta') because of the keyup bug.
+    if "meta" in combo.keys or "cmd" in combo.keys
+        non_modifier_keys = combo.keys.slice()
+        for mod_key in _modifier_keys
+            if (i = non_modifier_keys.indexOf(mod_key)) > -1
+                non_modifier_keys.splice(i, 1)
+        if non_modifier_keys.length > 1
+            _log_error "META and CMD key combos cannot have more than 1 non-modifier keys", combo, non_modifier_keys
+            validated = false
+
+    # Tell the user if they are trying to use any
+    # combo properties that don't actually exist,
+    # but allow the combo
+    for property, value of combo
+        if _factory_defaults[property] is "undefined"
+            _log_error "The property #{property} is not a valid combo property. Your combo has still been registered."
+
+    return validated
+
+_convert_to_shifted_key = (key, e) ->
+    return false unless e.shiftKey
+    k = _keycode_shifted_keys[key]
+    return k if k?
+    return false
+
+##########################
+# Key Mapping Dictionaries
+##########################
+
+_modifier_event_mapping =
+    "cmd"   : "metaKey"
+    "ctrl"  : "ctrlKey"
+    "shift" : "shiftKey"
+    "alt"   : "altKey"
+
+_keycode_alternate_names =
+    "escape"        : "esc"
+    "control"       : "ctrl"
+    "command"       : "cmd"
+    "break"         : "pause"
+    "windows"       : "cmd"
+    "option"        : "alt"
+    "caps_lock"     : "caps"
+    "apostrophe"    : "\'"
+    "semicolon"     : ";"
+    "tilde"         : "~"
+    "accent"        : "`"
+    "scroll_lock"   : "scroll"
+    "num_lock"      : "num"
+
+_keycode_shifted_keys =
+    "/"     : "?"
+    "."     : ">"
+    ","     : "<"
+    "\'"    : "\""
+    ";"     : ":"
+    "["     : "{"
+    "]"     : "}"
+    "\\"    : "|"
+    "`"     : "~"
+    "="     : "+"
+    "-"     : "_"
+    "1"     : "!"
+    "2"     : "@"
+    "3"     : "#"
+    "4"     : "$"
+    "5"     : "%"
+    "6"     : "^"
+    "7"     : "&"
+    "8"     : "*"
+    "9"     : "("
+    "0"     : ")"
+
+_keycode_dictionary =
+    0   : "\\"          # Firefox reports this keyCode when shift is held
+    8   : "backspace"
+    9   : "tab"
+    12  : "num"
+    13  : "enter"
+    16  : "shift"
+    17  : "ctrl"
+    18  : "alt"
+    19  : "pause"
+    20  : "caps"
+    27  : "esc"
+    32  : "space"
+    33  : "pageup"
+    34  : "pagedown"
+    35  : "end"
+    36  : "home"
+    37  : "left"
+    38  : "up"
+    39  : "right"
+    40  : "down"
+    44  : "print"
+    45  : "insert"
+    46  : "delete"
+    48  : "0"
+    49  : "1"
+    50  : "2"
+    51  : "3"
+    52  : "4"
+    53  : "5"
+    54  : "6"
+    55  : "7"
+    56  : "8"
+    57  : "9"
+    65  : "a"
+    66  : "b"
+    67  : "c"
+    68  : "d"
+    69  : "e"
+    70  : "f"
+    71  : "g"
+    72  : "h"
+    73  : "i"
+    74  : "j"
+    75  : "k"
+    76  : "l"
+    77  : "m"
+    78  : "n"
+    79  : "o"
+    80  : "p"
+    81  : "q"
+    82  : "r"
+    83  : "s"
+    84  : "t"
+    85  : "u"
+    86  : "v"
+    87  : "w"
+    88  : "x"
+    89  : "y"
+    90  : "z"
+    91  : "cmd"
+    92  : "cmd"
+    93  : "cmd"
+    96  : "num_0"
+    97  : "num_1"
+    98  : "num_2"
+    99  : "num_3"
+    100 : "num_4"
+    101 : "num_5"
+    102 : "num_6"
+    103 : "num_7"
+    104 : "num_8"
+    105 : "num_9"
+    106 : "num_multiply"
+    107 : "num_add"
+    108 : "num_enter"
+    109 : "num_subtract"
+    110 : "num_decimal"
+    111 : "num_divide"
+    124 : "print"
+    144 : "num"
+    145 : "scroll"
+    186 : ";"
+    187 : "="
+    188 : ","
+    189 : "-"
+    190 : "."
+    191 : "/"
+    192 : "`"
+    219 : "["
+    220 : "\\"
+    221 : "]"
+    222 : "\'"
+    223 : "`"
+    224 : "cmd"
+    225 : "alt"
+    # Opera weirdness
+    57392   : "ctrl"
+    63289   : "num"
+
+############
+# Initialize
+############
+
+_decide_meta_key()
+_change_keycodes_by_browser()

data/lib/atlas_assets/version.rb

@@ -1,5 +1,5 @@
 module Atlas
 	module Assets
-		VERSION = "0.6.4"
+		VERSION = "0.6.5"
 	end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: atlas_assets
 version: !ruby/object:Gem::Version
-  version: 0.6.4
+  version: 0.6.5
 platform: ruby
 authors:
 - Rune Skjoldborg Madsen
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-03-21 00:00:00.000000000 Z
+date: 2014-04-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: handlebars_assets
@@ -60,6 +60,7 @@ files:
 - docs/_posts/2013-09-12-logo.md
 - docs/_posts/2013-10-28-dropdown.md
 - docs/_posts/2014-03-12-drop.md
+- docs/_posts/2014-04-03-keypress.md
 - docs/_posts/2014-2-10-colors.md
 - docs/glyphicons-license.txt
 - docs/index.html
@@ -88,7 +89,7 @@ files:
 - lib/assets/javascripts/libraries/drop.js
 - lib/assets/javascripts/libraries/jquery.js
 - lib/assets/javascripts/libraries/jquery_ujs.js
-- lib/assets/javascripts/libraries/keypress.js
+- lib/assets/javascripts/libraries/keypress.coffee
 - lib/assets/javascripts/libraries/pusher.js
 - lib/assets/javascripts/libraries/select.coffee
 - lib/assets/javascripts/libraries/string.js

data/lib/assets/javascripts/libraries/keypress.js

@@ -1,22 +0,0 @@
-
-/* Keypress version 1.0.8 */
-(function(){var w,x,j,Q,R,S,T,y,z,A,U,G,H,m,V,W,X,Y,I,Z,$,aa,ba,ca,J,da,r,s,g,K,t,ea,L,u,M,B,v,N,C,h,O,D,p,E,P,F,fa,i=[].indexOf||function(a){for(var c=0,b=this.length;c<b;c++)if(c in this&&this[c]===a)return c;return-1},ga={}.hasOwnProperty;Array.prototype.filter||(Array.prototype.filter=function(a){var c,b,d,e;e=[];b=0;for(d=this.length;b<d;b++)c=this[b],a(c)&&e.push(c);return e});h=[];p=[];E=null;g=[];j=[];B=!1;L="ctrl";M="meta alt option ctrl shift cmd".split(" ");F=[];z={keys:[],count:0};t=function(){return console.log.apply(console,
-arguments)};A=function(a,c){var b,d,e;if(a.length!==c.length)return false;d=0;for(e=a.length;d<e;d++){b=a[d];if(!(i.call(c,b)>=0))return false}return true};U=function(a,c){var b,d,e;if(a.length!==c.length)return false;b=d=0;for(e=a.length;0<=e?d<e:d>e;b=0<=e?++d:--d)if(a[b]!==c[b])return false;return true};aa=function(a,c){var b,d,e;d=0;for(e=a.length;d<e;d++){b=a[d];if(i.call(c,b)<0)return false}return true};ba=function(a,c){var b,d,e,f;e=d=0;for(f=a.length;e<f;e++){b=a[e];b=c.indexOf(b);if(b>=d)d=
-b;else return false}return true};v=function(a,c){if((c||keypress.suppress_event_defaults)&&!keypress.force_event_defaults){a.preventDefault?a.preventDefault():a.returnValue=false;if(a.stopPropagation)return a.stopPropagation()}};S=function(a){if(a.prevent_repeat)return false;if(typeof a.on_keydown==="function")return true};K=function(a){var c,b,d,e;e=a.keys;b=0;for(d=e.length;b<d;b++){a=e[b];if(i.call(g,a)>=0){c=true;break}}return c};m=function(a,c,b){typeof c["on_"+a]==="function"&&v(b,c["on_"+a].call(c["this"],
-b,c.count)===false);if(a==="release")c.count=0;if(a==="keyup")return c.keyup_fired=true};ea=function(a,c){var b,d,e;d=0;for(e=h.length;d<e;d++){b=h[d];(b.is_ordered&&U(a,b.keys)||!b.is_ordered&&A(a,b.keys))&&c(b)}};V=function(a,c){var b,d,e;d=0;for(e=h.length;d<e;d++){b=h[d];(b.is_ordered&&ba(b.keys,a)||!b.is_ordered&&aa(b.keys,a))&&c(b)}};y=function(a){return i.call(g,"cmd")>=0&&i.call(a,"cmd")<0?false:true};W=function(a){var c,b;c=[];b=g.filter(function(b){return b!==a});b.push(a);ea(b,function(a){if(y(a.keys))return c.push(a)});
-V(b,function(a){if(!(i.call(c,a)>=0)&&!a.is_solitary&&y(a.keys))return c.push(a)});return c};Y=function(a){var c,b,d,e;b=[];d=0;for(e=h.length;d<e;d++){c=h[d];c.is_sequence||i.call(c.keys,a)>=0&&y(c.keys)&&b.push(c)}return b};R=function(a){var c,b,d,e,f,q,g,h,l,k,o;q=false;f=true;d=false;if(i.call(j,a)>=0)return true;if(j.length){e=g=0;for(k=j.length;0<=k?g<k:g>k;e=0<=k?++g:--g)if((c=j[e])&&c.is_exclusive&&a.is_exclusive){c=c.keys;if(!q){h=0;for(l=c.length;h<l;h++){b=c[h];q=true;if(i.call(a.keys,
-b)<0){q=false;break}}}if(f&&!q){o=a.keys;h=0;for(l=o.length;h<l;h++){b=o[h];f=false;if(i.call(c,b)<0){f=true;break}}}if(q){if(d)D(j.splice(e,1));else{D(j.splice(e,1,a));d=true}f=false}}}f&&j.unshift(a);return q||f};O=function(a){var c,b,d,e;b=d=0;for(e=j.length;0<=e?d<e:d>e;b=0<=e?++d:--d){c=j[b];if(c===a){D(j.splice(b,1));break}}};D=function(a){if(a){a.count=null;return a.keyup_fired=null}};Q=function(a,c){var b,d,e,f;p.push(a);d=X();if(d.length){e=0;for(f=d.length;e<f;e++){b=d[e];v(c,b.prevent_default)}E&&
-clearTimeout(E);keypress.sequence_delay>-1&&(E=setTimeout(function(){return p=[]},keypress.sequence_delay))}else p=[]};X=function(){var a,c,b,d,e,f,g,n,j,l,k;d=[];f=0;for(j=h.length;f<j;f++){a=h[f];c=g=1;for(l=p.length;1<=l?g<=l:g>=l;c=1<=l?++g:--g){e=p.slice(-c);if(a.is_sequence){if(i.call(a.keys,"shift")<0){e=e.filter(function(a){return a!=="shift"});if(!e.length)continue}c=n=0;for(k=e.length;0<=k?n<k:n>k;c=0<=k?++n:--n)if(a.keys[c]===e[c])b=true;else{b=false;break}b&&d.push(a)}}}return d};I=function(a){var c,
-b,d,e,f,g,j,m,l,k,o;g=0;for(l=h.length;g<l;g++){c=h[g];if(c.is_sequence){b=j=1;for(k=p.length;1<=k?j<=k:j>=k;b=1<=k?++j:--j){f=p.filter(function(a){return i.call(c.keys,"shift")>=0?true:a!=="shift"}).slice(-b);if(c.keys.length===f.length){b=m=0;for(o=f.length;0<=o?m<o:m>o;b=0<=o?++m:--m){e=f[b];if(!(i.call(c.keys,"shift")<0&&e==="shift")&&!(a==="shift"&&i.call(c.keys,"shift")<0))if(c.keys[b]===e)d=true;else{d=false;break}}}}if(d)return c}}return false};H=function(a,c){var b;if(!c.shiftKey)return false;
-b=s[a];return b!=null?b:false};Z=function(a,c,b){if(i.call(a.keys,c)<0)return false;v(b,a&&a.prevent_default);if(i.call(g,c)>=0&&!S(a))return false;c=R(a,c);a.keyup_fired=false;if(a.is_counting&&typeof a.on_keydown==="function")a.count=a.count+1;if(c)return m("keydown",a,b)};ca=function(a,c){var b,d,e,f;(d=H(a,c))&&(a=d);Q(a,c);(d=I(a))&&m("keydown",d,c);for(b in u){d=u[b];c[d]&&(b===a||i.call(g,b)>=0||g.push(b))}for(b in u){d=u[b];if(b!==a&&i.call(g,b)>=0&&!c[d]){d=e=0;for(f=g.length;0<=f?e<f:e>
-f;d=0<=f?++e:--e)g[d]===b&&g.splice(d,1)}}d=W(a);e=0;for(f=d.length;e<f;e++){b=d[e];Z(b,a,c)}d=Y(a);if(d.length){e=0;for(f=d.length;e<f;e++){b=d[e];v(c,b.prevent_default)}}i.call(g,a)<0&&g.push(a)};$=function(a,c,b){var d,e;e=K(a);if(!a.keyup_fired){d=g.slice();d.push(b);if(!a.is_solitary||A(d,a.keys)){m("keyup",a,c);if(a.is_counting&&typeof a.on_keyup==="function"&&typeof a.on_keydown!=="function")a.count=a.count+1}}if(!e){m("release",a,c);O(a)}};J=function(a,c){var b,d,e,f,h,n;d=a;(e=H(a,c))&&(a=
-e);e=s[d];c.shiftKey?e&&i.call(g,e)>=0||(a=d):d&&i.call(g,d)>=0||(a=e);(f=I(a))&&m("keyup",f,c);if(i.call(g,a)<0)return false;f=h=0;for(n=g.length;0<=n?h<n:h>n;f=0<=n?++h:--h)if((b=g[f])===a||b===e||b===d){g.splice(f,1);break}d=j.length;e=[];f=0;for(h=j.length;f<h;f++){b=j[f];i.call(b.keys,a)>=0&&e.push(b)}f=0;for(h=e.length;f<h;f++){b=e[f];$(b,c,a)}if(d>1){d=0;for(f=j.length;d<f;d++){b=j[d];b===void 0||i.call(e,b)>=0||K(b)||O(b)}}};C=function(a,c){var b;if(B)g.length&&(g=[]);else if(c||g.length)if(b=
-G(a.keyCode))return c?ca(b,a):J(b,a)};P=function(a){var c,b,d,e;e=[];c=b=0;for(d=h.length;0<=d?b<d:b>d;c=0<=d?++b:--b)if(a===h[c]){h.splice(c,1);break}else e.push(void 0);return e};fa=function(a){var c,b,d,e,f;a.keys.length||t("You're trying to bind a combo with no keys.");b=e=0;for(f=a.keys.length;0<=f?e<f:e>f;b=0<=f?++e:--e){d=a.keys[b];(c=da[d])&&(d=a.keys[b]=c);d==="meta"&&a.keys.splice(b,1,L);d==="cmd"&&t('Warning: use the "meta" key rather than "cmd" for Windows compatibility')}f=a.keys;c=0;
-for(e=f.length;c<e;c++){d=f[c];if(i.call(F,d)<0){t('Do not recognize the key "'+d+'"');return false}}if(i.call(a.keys,"meta")>=0||i.call(a.keys,"cmd")>=0){c=a.keys.slice();e=0;for(f=M.length;e<f;e++){d=M[e];(b=c.indexOf(d))>-1&&c.splice(b,1)}c.length>1&&t("META and CMD key combos cannot have more than 1 non-modifier keys",a,c)}return true};T=function(a){var c;if(i.call(g,"cmd")>=0&&(c=G(a.keyCode))!=="cmd"&&c!=="shift"&&c!=="alt"&&c!=="caps"&&c!=="tab")return C(a,false)};window.keypress={};keypress.force_event_defaults=
-!1;keypress.suppress_event_defaults=!1;keypress.sequence_delay=800;keypress.get_registered_combos=function(){return h};keypress.reset=function(){h=[]};keypress.combo=function(a,c,b){b==null&&(b=false);return keypress.register_combo({keys:a,on_keydown:c,prevent_default:b})};keypress.counting_combo=function(a,c,b){b==null&&(b=false);return keypress.register_combo({keys:a,is_counting:true,is_ordered:true,on_keydown:c,prevent_default:b})};keypress.sequence_combo=function(a,c,b){b==null&&(b=false);return keypress.register_combo({keys:a,
-on_keydown:c,is_sequence:true,prevent_default:b})};keypress.register_combo=function(a){var c,b;if(typeof a.keys==="string")a.keys=a.keys.split(" ");for(c in z)if(ga.call(z,c)){b=z[c];a[c]==null&&(a[c]=b)}if(fa(a)){h.push(a);return true}};keypress.register_many=function(a){var c,b,d,e;e=[];b=0;for(d=a.length;b<d;b++){c=a[b];e.push(keypress.register_combo(c))}return e};keypress.unregister_combo=function(a){var c,b,d;if(!a)return false;if(a.keys)return P(a);d=[];c=0;for(b=h.length;c<b;c++)(a=h[c])&&
-(A(keys,a.keys)?d.push(P(a)):d.push(void 0));return d};keypress.unregister_many=function(a){var c,b,d,e;e=[];b=0;for(d=a.length;b<d;b++){c=a[b];e.push(keypress.unregister_combo(c))}return e};keypress.listen=function(){return B=false};keypress.stop_listening=function(){return B=true};G=function(a){return r[a]};u={cmd:"metaKey",ctrl:"ctrlKey",shift:"shiftKey",alt:"altKey"};da={control:"ctrl",command:"cmd","break":"pause",windows:"cmd",option:"alt",caps_lock:"caps",apostrophe:"'",semicolon:";",tilde:"~",
-accent:"`",scroll_lock:"scroll",num_lock:"num"};s={"/":"?",".":">",",":"<","'":'"',";":":","[":"{","]":"}","\\":"|","`":"~","=":"+","-":"_",1:"!",2:"@",3:"#",4:"$",5:"%",6:"^",7:"&",8:"*",9:"(","0":")"};r={"0":"\\",8:"backspace",9:"tab",12:"num",13:"enter",16:"shift",17:"ctrl",18:"alt",19:"pause",20:"caps",27:"escape",32:"space",33:"pageup",34:"pagedown",35:"end",36:"home",37:"left",38:"up",39:"right",40:"down",44:"print",45:"insert",46:"delete",48:"0",49:"1",50:"2",51:"3",52:"4",53:"5",54:"6",55:"7",
-56:"8",57:"9",65:"a",66:"b",67:"c",68:"d",69:"e",70:"f",71:"g",72:"h",73:"i",74:"j",75:"k",76:"l",77:"m",78:"n",79:"o",80:"p",81:"q",82:"r",83:"s",84:"t",85:"u",86:"v",87:"w",88:"x",89:"y",90:"z",91:"cmd",92:"cmd",93:"cmd",96:"num_0",97:"num_1",98:"num_2",99:"num_3",100:"num_4",101:"num_5",102:"num_6",103:"num_7",104:"num_8",105:"num_9",106:"num_multiply",107:"num_add",108:"num_enter",109:"num_subtract",110:"num_decimal",111:"num_divide",124:"print",144:"num",145:"scroll",186:";",187:"=",188:",",
-189:"-",190:".",191:"/",192:"`",219:"[",220:"\\",221:"]",222:"'",223:"`",224:"cmd",57392:"ctrl",63289:"num"};for(x in r)w=r[x],F.push(w);for(x in s)w=s[x],F.push(w);-1!==navigator.userAgent.indexOf("Mac OS X")&&(L="cmd");-1!==navigator.userAgent.indexOf("Opera")&&(r["17"]="cmd");N=function(a){return(document.attachEvent?document.readyState==="complete":document.readyState!=="loading")?a():setTimeout(function(){return N(a)},9)};N(function(){var a;a=function(a,b,d){if(a.addEventListener)return a.addEventListener(b,
-d);if(a.attachEvent)return a.attachEvent("on"+b,d)};a(document.body,"keydown",function(a){a=a||window.event;C(a,true);return T(a)});a(document.body,"keyup",function(a){a=a||window.event;return C(a,false)});return a(window,"blur",function(){var a,b,d;b=0;for(d=g.length;b<d;b++){a=g[b];J(a,{})}g=[];return[]})})}).call(this);