From dc824485aa893250e442dc5232f8a628cb1ab21a Mon Sep 17 00:00:00 2001
From: Kevin Sawicki <kevin@github.com>
Date: Tue, 28 Oct 2014 16:55:36 -0700
Subject: [PATCH] Pass character codes around in TextUtils

Previously the character codes were looked up for each type of character pair.
---
 src/text-utils.coffee | 63 +++++++++++++++++++++++--------------------
 src/workspace.coffee  |  3 +++
 2 files changed, 37 insertions(+), 29 deletions(-)

diff --git a/src/text-utils.coffee b/src/text-utils.coffee
index 03aa68a29..37955dcd6 100644
--- a/src/text-utils.coffee
+++ b/src/text-utils.coffee
@@ -1,56 +1,61 @@
-isHighSurrogate = (string, index) ->
-  0xD800 <= string.charCodeAt(index) <= 0xDBFF
+isHighSurrogate = (charCode) ->
+  0xD800 <= charCode <= 0xDBFF
 
-isLowSurrogate = (string, index) ->
-  0xDC00 <= string.charCodeAt(index) <= 0xDFFF
+isLowSurrogate = (charCode) ->
+  0xDC00 <= charCode <= 0xDFFF
 
-isVariationSelector = (string, index) ->
-  0xFE00 <= string.charCodeAt(index) <= 0xFE0F
+isVariationSelector = (charCode) ->
+  0xFE00 <= charCode <= 0xFE0F
 
-isCombiningCharacter = (string, index) ->
-  0x0300 <= string.charCodeAt(index) <= 0x036F or
-  0x1AB0 <= string.charCodeAt(index) <= 0x1AFF or
-  0x1DC0 <= string.charCodeAt(index) <= 0x1DFF or
-  0x20D0 <= string.charCodeAt(index) <= 0x20FF or
-  0xFE20 <= string.charCodeAt(index) <= 0xFE2F
+isCombiningCharacter = (charCode) ->
+  0x0300 <= charCode <= 0x036F or
+  0x1AB0 <= charCode <= 0x1AFF or
+  0x1DC0 <= charCode <= 0x1DFF or
+  0x20D0 <= charCode <= 0x20FF or
+  0xFE20 <= charCode <= 0xFE2F
 
-# Is the character at the given index the start of a high/low surrogate pair?
+# Are the given character codes a high/low surrogate pair?
 #
-# * `string` The {String} to check for a surrogate pair.
-# * `index`  The {Number} index to look for a surrogate pair at.
+# * `charCodeA` The first character code {Number}.
+# * `charCode2` The second character code {Number}.
 #
 # Return a {Boolean}.
-isSurrogatePair = (string, index=0) ->
-  isHighSurrogate(string, index) and isLowSurrogate(string, index + 1)
+isSurrogatePair = (charCodeA, charCodeB) ->
+  isHighSurrogate(charCodeA) and isLowSurrogate(charCodeB)
 
-# Is the character at the given index the start of a variation sequence?
+# Are the given character codes a variation sequence?
 #
-# * `string` The {String} to check for a variation sequence.
-# * `index`  The {Number} index to look for a variation sequence at.
+# * `charCodeA` The first character code {Number}.
+# * `charCode2` The second character code {Number}.
 #
 # Return a {Boolean}.
-isVariationSequence = (string, index=0) ->
-  not isVariationSelector(string, index) and isVariationSelector(string, index + 1)
+isVariationSequence = (charCodeA, charCodeB) ->
+  not isVariationSelector(charCodeA) and isVariationSelector(charCodeB)
 
-# Is the character at the given index the start of a combined character pair?
+# Are the given character codes a combined character pair?
 #
-# * `string` The {String} to check for a combined character.
-# * `index`  The {Number} index to look for a variation sequence at.
+# * `charCodeA` The first character code {Number}.
+# * `charCode2` The second character code {Number}.
 #
 # Return a {Boolean}.
-isCombinedCharacter = (string, index=0) ->
-  not isCombiningCharacter(string, index) and isCombiningCharacter(string, index + 1)
+isCombinedCharacter = (charCodeA, charCodeB) ->
+  not isCombiningCharacter(charCodeA) and isCombiningCharacter(charCodeB)
 
 # Is the character at the given index the start of high/low surrogate pair
 # a variation sequence, or a combined character?
 #
 # * `string` The {String} to check for a surrogate pair, variation sequence,
 #            or combined character.
-# * `index`  The {Number} index to look for a surrogate pair at.
+# * `index`  The {Number} index to look for a surrogate pair, variation
+#            sequence, or combined character.
 #
 # Return a {Boolean}.
 isPairedCharacter = (string, index=0) ->
-  isSurrogatePair(string, index) or isVariationSequence(string, index) or isCombinedCharacter(string, index)
+  charCodeA = string.charCodeAt(index)
+  charCodeB = string.charCodeAt(index + 1)
+  isSurrogatePair(charCodeA, charCodeB) or
+  isVariationSequence(charCodeA, charCodeB) or
+  isCombinedCharacter(charCodeA, charCodeB)
 
 # Does the given string contain at least surrogate pair, variation sequence,
 # or combined character?
diff --git a/src/workspace.coffee b/src/workspace.coffee
index 5b640b61b..86a9f1e00 100644
--- a/src/workspace.coffee
+++ b/src/workspace.coffee
@@ -402,6 +402,8 @@ class Workspace extends Model
       item ?= opener(atom.project.resolve(uri), options) for opener in @getOpeners() when !item
     item ?= atom.project.open(uri, options)
 
+    console.profile('open')
+
     Q(item)
       .then (item) =>
         if not pane
@@ -413,6 +415,7 @@ class Workspace extends Model
         index = pane.getActiveItemIndex()
         @emit "uri-opened"
         @emitter.emit 'did-open', {uri, pane, item, index}
+        console.profileEnd('open')
         item
       .catch (error) ->
         console.error(error.stack ? error)