Merge pull request #6 from viablelab/feature/auto-close-fix

Feature/auto close fix

Author: mrwest808

lib/bracket-padder.coffee

@@ -1,14 +1,15 @@
 {
-  adviseBefore, contains, findLastIndex,
-  first, has, invert, keys,
+  adviseBefore, first, invert,
+  compose, last, filter,
 } = require 'underscore-plus'
 
 pairsToPad =
   '(': ')'
   '[': ']'
   '{': '}'
 
-invertedPairsToPad = invert pairsToPad
+invertedPairsToPad =
+  invert pairsToPad
 
 pairsToUnpad =
   '( ': ' )'
@@ -22,6 +23,9 @@ defaultPairs = [
   '"', "'", '`',
 ]
 
+removeEscapedQuotes =
+  (str) -> str.replace(/(\\"|\\')/g, '')
+
 module.exports =
 class BracketPadder
   constructor: (@editor) ->
@@ -32,15 +36,17 @@ class BracketPadder
     return true unless text
     return true if options?.select or options?.undo is 'skip'
 
-    closingBracket = invertedPairsToPad[text]
-    return true unless text is ' ' or closingBracket
+    openBracket = invertedPairsToPad[text]
+    isClosingBracket = !!openBracket
+
+    return true unless text is ' ' or isClosingBracket
 
     if @shouldPad(text)
       @editor.insertText('  ')
       @editor.moveLeft()
       return false
 
-    if @shouldClosePair(closingBracket)
+    if @shouldClosePair(text, openBracket)
       @editor.moveRight(2)
       return false
 
@@ -51,9 +57,7 @@ class BracketPadder
     previousCharacters = @getPreviousCharacters(2, cursor)
     nextCharacters = @getNextCharacters(2, cursor)
 
-    match = pairsToUnpad[previousCharacters]
-
-    return true unless match and nextCharacters is match
+    return true unless pairsToUnpad[previousCharacters] is nextCharacters
 
     @editor.moveRight()
     @editor.backspace()
@@ -67,25 +71,24 @@ class BracketPadder
     previousCharacter = @getPreviousCharacters 1, cursor
     nextCharacter = @getNextCharacters 1, cursor
 
-    match = pairsToPad[previousCharacter]
-    return match and nextCharacter is match
+    return true if pairsToPad[previousCharacter] is nextCharacter
 
-  shouldClosePair: (character) =>
+  shouldClosePair: (closeBracket, openBracket) =>
     cursor = @editor.getCursorBufferPosition()
-    previousCharacters = @getPreviousCharacters(cursor.column, cursor)
+    previousCharacters =
+      removeEscapedQuotes @getPreviousCharacters(cursor.column, cursor)
+    nextCharacters = @getNextCharacters(2, cursor)
 
-    match = findLastOccurringCharacter defaultPairs, previousCharacters
-    return false unless match and match is character
+    return false unless previousCharacters.includes(openBracket)
 
-    nextCharacters = @getNextCharacters(2, cursor)
+    unclosed = getUnclosedPairs(previousCharacters)
+    return false unless last(unclosed) is openBracket
 
     return false unless first(nextCharacters) is ' '
-
-    match = invert(pairsToPad)[nextCharacters.trim()]
-    return match and match is character
+    return true if nextCharacters.trim() is closeBracket
 
   getPreviousCharacters: (count, cursor) =>
-    return -1 unless cursor.column
+    return '' unless cursor.column
 
     return @editor.getTextInBufferRange([
       cursor.traverse([0, -count]),
@@ -99,16 +102,35 @@ class BracketPadder
     ])
 
 ###
- * @param {Array<String>} characters
- * @param {String} string
+ * Filters out characters between `opening` and `closing` characters.
+ * @param  {String} opening
+ * @param  {String} closing
+ * @return {Function}
 ###
-findLastOccurringCharacter = (characters, string) ->
-  index = string.length - 1
+removePairs = (opening, closing) -> (str) ->
+  if not closing
+    closing = opening
 
-  while index--
-    char = string[index]
+  regex = new RegExp("#{opening}([^#{opening}]+(?=#{closing}))#{closing}", 'g')
+  str.replace(regex, '')
 
-    if contains(characters, char)
-      return char
+###
+ * :: String -> String
+###
+removeClosedPairs = compose(
+  removePairs("'"),
+  removePairs('"'),
+  removePairs('`'),
+  removePairs('\\{', '\\}'),
+  removePairs('\\[', '\\]'),
+  removePairs('\\(', '\\)')
+)
 
-  return undefined
+###
+ * Returns any unclosed "bracket pair characters" found within `str`.
+ * @param  {String} str
+ * @return {Array<String>}
+###
+getUnclosedPairs = (str) ->
+  trimmed = removeClosedPairs(str)
+  return filter(trimmed, (char) -> defaultPairs.includes(char))

spec/bracket-padder-spec.coffee

@@ -80,27 +80,74 @@ describe "bracket padding", ->
 
     expect(test).not.toThrow()
 
-  # it 'autocloses padded (), [], {} pairs', ->
-  #   testPair = (opening, closing) ->
-  #     editor.selectAll()
-  #     editor.delete()
-  #
-  #     editor.insertText(opening)
-  #     editor.insertText(' ')
-  #     editor
-  #
-  #     editor.insertText("#{opening} #{closing}")
-  #     editor.setCursorBufferPosition([0, 2])
-  #     editor.insertText(closing)
-  #
-  #     actualText = editor.buffer.getText()
-  #     expectedText = "#{opening} #{closing}"
-  #     expect(actualText).toBe expectedText
-  #
-  #     actualCursorPosition = editor.getCursorBufferPosition().column
-  #     expectedCursorPosition = 4
-  #     expect(actualCursorPosition).toBe expectedCursorPosition
-  #
-  #   testPair '(', ')'
-  #   testPair '[', ']'
-  #   testPair '{', '}'
+  it 'autocloses padded (), [], {} pairs properly', ->
+    reset = ->
+      editor.selectAll()
+      editor.delete()
+
+    testPair = (opening, closing) ->
+      reset()
+
+      testStrings = [
+        'foo: bar'
+        '"foo": "bar"'
+        "'foo': 'bar'"
+        '`foo`: `bar`'
+        '[foo]: [bar]'
+        '{foo}: {bar}'
+        '(foo): (bar)'
+      ]
+
+      testStrings.forEach (str) ->
+        reset()
+
+        text = "#{opening} #{str} #{closing}"
+        editor.insertText(text)
+
+        editor.moveToEndOfLine()
+        editor.moveLeft(2)
+
+        editor.insertText(closing)
+
+        expected = text
+        actual = editor.buffer.getText()
+
+        expect(actual).toBe(expected)
+
+    testPair '(', ')'
+    testPair '[', ']'
+    testPair '{', '}'
+
+  it 'skips autoclosing when cursor is within unclosed quotes', ->
+    reset = ->
+      editor.selectAll()
+      editor.delete()
+
+    testPair = (opening, closing) ->
+      reset()
+
+      testStrings = [
+        '"foo": "bar'
+        "'foo: 'bar'"
+        '`foo`: `bar'
+      ]
+
+      testStrings.forEach (str) ->
+        reset()
+
+        text = "#{opening} #{str} #{closing}"
+        editor.insertText(text)
+
+        editor.moveToEndOfLine()
+        editor.moveLeft(2)
+
+        editor.insertText(closing)
+
+        expected = "#{opening} #{str}#{closing} #{closing}"
+        actual = editor.buffer.getText()
+
+        expect(actual).toBe(expected)
+
+    testPair '(', ')'
+    testPair '[', ']'
+    testPair '{', '}'