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
|
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, whether :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
'(?::(\\d+))?$' # port number (optional) => \4
)
# these are all official ASCII TLDs that are longer than 3 characters
# (including the inofficial .onion TLD used by TOR)
longTlds = [ 'arpa', 'asia', 'coop', 'info', 'jobs', 'local', 'mobi', 'museum', 'name', 'onion' ]
# are there more?
specialHostNames = [ 'localhost' ]
# it starts with a scheme, so it's definitely an URL
if (/^[a-z]{3,}:\/\//.test(str))
return true
# spaces => definitely not a valid URL
if (str.indexOf(' ') >= 0)
return false
# assuming that this is an URL, try to parse it 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])
if (!match)
return false
hostname = match[3]
# allow known special host names
if (specialHostNames.indexOf(hostname) >= 0)
return true
# allow IPv6 addresses (need to be wrapped in brackets, as required by RFC). It is sufficient to check
# for a colon here, as the regex wouldn't match colons in the host name unless it's an v6 address
if (hostname.indexOf(':') >= 0)
return true
# 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('.')
lastPart = dottedParts[dottedParts.length-1]
if (dottedParts.length > 1 && ((lastPart.length >= 2 && lastPart.length <= 3) ||
longTlds.indexOf(lastPart) >= 0))
return true
# also allow IPv4 addresses
if (/^(\d{1,3}\.){3}\d{1,3}$/.test(hostname))
return true
# 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
|
