1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
|
Utils =
getCurrentVersion: ->
# Chromium #15242 will make this XHR request to access the manifest unnecessary.
manifestRequest = new XMLHttpRequest()
manifestRequest.open("GET", chrome.extension.getURL("manifest.json"), false)
manifestRequest.send(null)
JSON.parse(manifestRequest.responseText).version
# Takes a dot-notation object string and call the function
# that it points to with the correct value for 'this'.
invokeCommandString: (str, argArray) ->
components = str.split('.')
obj = window
for component in components[0...-1]
obj = obj[component]
func = obj[components.pop()]
func.apply(obj, argArray)
# Creates a single DOM element from :html
createElementFromHtml: (html) ->
tmp = document.createElement("div")
tmp.innerHTML = html
tmp.firstChild
escapeHtml: (string) -> string.replace(/</g, "<").replace(/>/g, ">")
# Generates a unique ID
createUniqueId: (->
id = 0
return -> id += 1
)()
hasChromePrefix: (url) ->
chromePrefixes = [ 'about', 'view-source' ]
for prefix in chromePrefixes
return true if url.startsWith prefix
false
# Completes a partial URL (without scheme)
createFullUrl: (partialUrl) ->
if (!/^[a-z]{3,}:\/\//.test(partialUrl))
"http://" + partialUrl
else
partialUrl
# Tries to detect if :str is a valid URL.
isUrl: (str) ->
# More or less RFC compliant URL host part parsing. This should be
# sufficient for our needs
urlRegex = new RegExp(
# user:password (optional) => \1, \2
'^(?:([^:]+)(?::([^:]+))?@)?' +
# host name (IPv6 addresses in square brackets allowed) => \3
'([^:]+|\\[[^\\]]+\\])' +
# port number (optional) => \4
'(?::(\\d+))?$'
)
# Official ASCII TLDs that are longer than 3 characters
longTlds = [
'arpa'
'asia'
'coop'
'info'
'jobs'
'local'
'mobi'
'museum'
'name'
'onion' # Inofficial .onion TLD used by TOR
]
specialHostNames = ['localhost']
# Starts with a scheme: URL
return true if /^[a-z]{3,}:\/\//.test str
# Must not contain spaces
return false if ' ' in str
# Try to parse the URL into its meaningful parts. If matching fails we're
# pretty sure that we don't have some kind of URL here.
match = urlRegex.exec (str.split '/')[0]
return false unless match
hostName = match[3]
# Allow known special host names
return true if hostName in specialHostNames
# Allow IPv6 addresses (need to be wrapped in brackets as required by
# RFC). It is sufficient to check for a colon, as the regex wouldn't
# match colons in the host name unless it's an v6 address
return true if ':' in hostName
# At this point we have to make a decision. As a heuristic, we check
# if the input has dots in it. If yes, and if the last part could be a
# TLD, treat it as an URL
dottedParts = hostName.split '.'
if dottedParts.length > 1
lastPart = dottedParts.pop()
return true if 2 <= lastPart.length <= 3 or lastPart in longTlds
# Allow IPv4 addresses
return true if /^(\d{1,3}\.){3}\d{1,3}$/.test hostName
# Fallback: no URL
return false
# Creates a search URL from the given :query.
createSearchUrl: (query) ->
# we need to escape explictely to encode characters like "+" correctly
"http://www.google.com/search?q=" + encodeURIComponent(query)
# Converts :string into a google search if it's not already a URL.
# We don't bother with escaping characters as Chrome will do that for us.
convertToUrl: (string) ->
string = string.trim()
# special-case about:[url] and view-source:[url]
if Utils.hasChromePrefix string then string
else
if (Utils.isUrl(string)) then Utils.createFullUrl(string) else Utils.createSearchUrl(string)
# This creates a new function out of an existing function, where the new function takes fewer arguments.
# This allows us to pass around functions instead of functions + a partial list of arguments.
Function.prototype.curry = ->
fixedArguments = Array.copy(arguments)
fn = this
-> fn.apply(this, fixedArguments.concat(Array.copy(arguments)))
Array.copy = (array) -> Array.prototype.slice.call(array, 0)
String::startsWith = (str) -> @indexOf(str) == 0
# A very simple method for defining a new class (constructor and methods) using a single hash.
# No support for inheritance is included because we really shouldn't need it.
# TODO(philc): remove this.
Class =
extend: (properties) ->
newClass = ->
this.init.apply(this, arguments) if (this.init)
null
newClass.prototype = properties
newClass.constructor = newClass
newClass
globalRoot = if window? then window else global
globalRoot.extend = (hash1, hash2) ->
for key of hash2
hash1[key] = hash2[key]
hash1
root = exports ? window
root.Utils = Utils
root.Class = Class
|
