Rename keyMapping to keyBinding

spec/atom-spec.coffee

@@ -137,28 +137,28 @@ describe "the `atom` global", ->
               element2 = $$ -> @div class: 'test-2'
               element3 = $$ -> @div class: 'test-3'
 
-              expect(atom.keymap.mappingsForKeystrokeMatchingElement('ctrl-z', element1)).toHaveLength 0
-              expect(atom.keymap.mappingsForKeystrokeMatchingElement('ctrl-z', element2)).toHaveLength 0
-              expect(atom.keymap.mappingsForKeystrokeMatchingElement('ctrl-z', element3)).toHaveLength 0
+              expect(atom.keymap.bindingsForKeystrokeMatchingElement('ctrl-z', element1)).toHaveLength 0
+              expect(atom.keymap.bindingsForKeystrokeMatchingElement('ctrl-z', element2)).toHaveLength 0
+              expect(atom.keymap.bindingsForKeystrokeMatchingElement('ctrl-z', element3)).toHaveLength 0
 
               atom.activatePackage("package-with-keymaps")
 
-              expect(atom.keymap.mappingsForKeystrokeMatchingElement('ctrl-z', element1)[0].command).toBe "test-1"
-              expect(atom.keymap.mappingsForKeystrokeMatchingElement('ctrl-z', element2)[0].command).toBe "test-2"
-              expect(atom.keymap.mappingsForKeystrokeMatchingElement('ctrl-z', element3)).toHaveLength 0
+              expect(atom.keymap.bindingsForKeystrokeMatchingElement('ctrl-z', element1)[0].command).toBe "test-1"
+              expect(atom.keymap.bindingsForKeystrokeMatchingElement('ctrl-z', element2)[0].command).toBe "test-2"
+              expect(atom.keymap.bindingsForKeystrokeMatchingElement('ctrl-z', element3)).toHaveLength 0
 
           describe "when the metadata contains a 'keymaps' manifest", ->
             it "loads only the keymaps specified by the manifest, in the specified order", ->
               element1 = $$ -> @div class: 'test-1'
               element3 = $$ -> @div class: 'test-3'
 
-              expect(atom.keymap.mappingsForKeystrokeMatchingElement('ctrl-z', element1)).toHaveLength 0
+              expect(atom.keymap.bindingsForKeystrokeMatchingElement('ctrl-z', element1)).toHaveLength 0
 
               atom.activatePackage("package-with-keymaps-manifest")
 
-              expect(atom.keymap.mappingsForKeystrokeMatchingElement('ctrl-z', element1)[0].command).toBe 'keymap-1'
-              expect(atom.keymap.mappingsForKeystrokeMatchingElement('ctrl-n', element1)[0].command).toBe 'keymap-2'
-              expect(atom.keymap.mappingsForKeystrokeMatchingElement('ctrl-y', element3)).toHaveLength 0
+              expect(atom.keymap.bindingsForKeystrokeMatchingElement('ctrl-z', element1)[0].command).toBe 'keymap-1'
+              expect(atom.keymap.bindingsForKeystrokeMatchingElement('ctrl-n', element1)[0].command).toBe 'keymap-2'
+              expect(atom.keymap.bindingsForKeystrokeMatchingElement('ctrl-y', element3)).toHaveLength 0
 
         describe "menu loading", ->
           beforeEach ->
@@ -317,8 +317,8 @@ describe "the `atom` global", ->
         it "removes the package's keymaps", ->
           atom.activatePackage('package-with-keymaps')
           atom.deactivatePackage('package-with-keymaps')
-          expect(atom.keymap.mappingsForKeystrokeMatchingElement('ctrl-z', $$ -> @div class: 'test-1')).toHaveLength 0
-          expect(atom.keymap.mappingsForKeystrokeMatchingElement('ctrl-z', $$ -> @div class: 'test-2')).toHaveLength 0
+          expect(atom.keymap.bindingsForKeystrokeMatchingElement('ctrl-z', $$ -> @div class: 'test-1')).toHaveLength 0
+          expect(atom.keymap.bindingsForKeystrokeMatchingElement('ctrl-z', $$ -> @div class: 'test-2')).toHaveLength 0
 
         it "removes the package's stylesheets", ->
           atom.activatePackage('package-with-stylesheets')

spec/keymap-spec.coffee

@@ -270,13 +270,13 @@ describe "Keymap", ->
         '.brown':
           'ctrl-h': 'harvest'
 
-      expect(keymap.mappingsMatchingElement($$ -> @div class: 'green')).toHaveLength 1
-      expect(keymap.mappingsMatchingElement($$ -> @div class: 'brown')).toHaveLength 1
+      expect(keymap.bindingsMatchingElement($$ -> @div class: 'green')).toHaveLength 1
+      expect(keymap.bindingsMatchingElement($$ -> @div class: 'brown')).toHaveLength 1
 
       keymap.remove('nature')
 
-      expect(keymap.mappingsMatchingElement($$ -> @div class: 'green')).toEqual []
-      expect(keymap.mappingsMatchingElement($$ -> @div class: 'brown')).toEqual []
+      expect(keymap.bindingsMatchingElement($$ -> @div class: 'green')).toEqual []
+      expect(keymap.bindingsMatchingElement($$ -> @div class: 'brown')).toEqual []
       expect(keymap.bindingSetsByFirstKeystroke['ctrl-c']).toEqual []
       expect(keymap.bindingSetsByFirstKeystroke['ctrl-h']).toEqual []
 
@@ -303,15 +303,15 @@ describe "Keymap", ->
         expect(keymap.keystrokeStringForEvent(keydownEvent('left', shiftKey: true))).toBe 'shift-left'
         expect(keymap.keystrokeStringForEvent(keydownEvent('Left', shiftKey: true))).toBe 'shift-left'
 
-  describe ".mappingsMatchingElement(element)", ->
+  describe ".bindingsMatchingElement(element)", ->
     it "returns the matching bindings for the element", ->
       keymap.bindKeys '.command-mode', 'c': 'c'
       keymap.bindKeys '.grandchild-node', 'g': 'g'
 
-      mappings = keymap.mappingsMatchingElement(fragment.find('.grandchild-node'))
-      expect(mappings).toHaveLength 2
-      expect(mappings[0].command).toEqual "g"
-      expect(mappings[1].command).toEqual "c"
+      bindings = keymap.bindingsMatchingElement(fragment.find('.grandchild-node'))
+      expect(bindings).toHaveLength 2
+      expect(bindings[0].command).toEqual "g"
+      expect(bindings[1].command).toEqual "c"
 
     describe "when multiple bindings match a keystroke", ->
       it "only returns bindings that match the most specific selector", ->
@@ -319,6 +319,6 @@ describe "Keymap", ->
         keymap.bindKeys '.command-mode .grandchild-node', 'g': 'command-and-grandchild-node'
         keymap.bindKeys '.grandchild-node', 'g': 'grandchild-node'
 
-        mappings = keymap.mappingsMatchingElement(fragment.find('.grandchild-node'))
-        expect(mappings).toHaveLength 3
-        expect(mappings[0].command).toEqual "command-and-grandchild-node"
+        bindings = keymap.bindingsMatchingElement(fragment.find('.grandchild-node'))
+        expect(bindings).toHaveLength 3
+        expect(bindings[0].command).toEqual "command-and-grandchild-node"

src/keymap.coffee

@@ -82,62 +82,62 @@ class Keymap
     element = event.target
     element = rootView[0] if element == document.body
     keystroke = @keystrokeStringForEvent(event, @queuedKeystroke)
-    mappings = @mappingsForKeystrokeMatchingElement(keystroke, element)
+    bindings = @bindingsForKeystrokeMatchingElement(keystroke, element)
 
-    if mappings.length == 0 and @queuedKeystroke
+    if bindings.length == 0 and @queuedKeystroke
       @queuedKeystroke = null
       return false
     else
       @queuedKeystroke = null
 
-    for mapping in mappings
-      partialMatch = mapping.keystroke isnt keystroke
+    for binding in bindings
+      partialMatch = binding.keystroke isnt keystroke
       if partialMatch
         @queuedKeystroke = keystroke
         shouldBubble = false
       else
-        if mapping.command is 'native!'
+        if binding.command is 'native!'
           shouldBubble = true
-        else if @triggerCommandEvent(element, mapping.command)
+        else if @triggerCommandEvent(element, binding.command)
           shouldBubble = false
 
       break if shouldBubble?
 
     shouldBubble ? true
 
-  # Public: Returns an array of objects that represent every keystroke to
-  # command mapping. Each object contains the following keys `source`,
-  # `selector`, `command`, `keystroke`, `index`, `specificity`.
-  allMappings: ->
-    mappings = []
+  # Public: Returns an array of objects that represent every keybinding. Each
+  # object contains the following keys `source`, `selector`, `command`,
+  # `keystroke`, `index`, `specificity`.
+  allBindings: ->
+    bindings = []
 
     for bindingSet in @bindingSets
       for keystroke, command of bindingSet.getCommandsByKeystroke()
-        mappings.push @buildMapping(bindingSet, command, keystroke)
+        bindings.push @buildBinding(bindingSet, command, keystroke)
 
-    mappings
+    bindings
 
-  mappingsForKeystrokeMatchingElement: (keystroke, element) ->
-    mappings = @mappingsForKeystroke(keystroke)
-    @mappingsMatchingElement(element, mappings)
+  bindingsForKeystrokeMatchingElement: (keystroke, element) ->
+    bindings = @bindingsForKeystroke(keystroke)
+    @bindingsMatchingElement(element, bindings)
 
-  mappingsForKeystroke: (keystroke) ->
-    mappings = @allMappings().filter (mapping) ->
+  bindingsForKeystroke: (keystroke) ->
+    bindings = @allBindings().filter (binding) ->
       multiKeystroke = /\s/.test keystroke
       if multiKeystroke
-        keystroke == mapping.keystroke
+        keystroke == binding.keystroke
       else
-        keystroke.split(' ')[0] == mapping.keystroke.split(' ')[0]
+        keystroke.split(' ')[0] == binding.keystroke.split(' ')[0]
 
-  mappingsMatchingElement: (element, mappings=@allMappings()) ->
-    mappings = mappings.filter ({selector}) -> $(element).closest(selector).length > 0
-    mappings.sort (a, b) ->
+  bindingsMatchingElement: (element, bindings=@allBindings()) ->
+    bindings = bindings.filter ({selector}) -> $(element).closest(selector).length > 0
+    bindings.sort (a, b) ->
       if b.specificity == a.specificity
         b.index - a.index
       else
         b.specificity - a.specificity
 
-  buildMapping: (bindingSet, command, keystroke) ->
+  buildBinding: (bindingSet, command, keystroke) ->
     selector = bindingSet.selector
     specificity = bindingSet.specificity
     index = bindingSet.index

src/menu-manager.coffee

@@ -31,9 +31,9 @@ class MenuManager
   update: ->
     keystrokesByCommand = {}
     selectors = ['body', '.editor', '.editor:not(.mini)']
-    for mapping in atom.keymap.allMappings() when mapping.selector in selectors
-      keystrokesByCommand[mapping.command] ?= []
-      keystrokesByCommand[mapping.command].push mapping.keystroke
+    for binding in atom.keymap.allBindings() when binding.selector in selectors
+      keystrokesByCommand[binding.command] ?= []
+      keystrokesByCommand[binding.command].push binding.keystroke
     @sendToBrowserProcess(@template, keystrokesByCommand)
 
   # Private