1
// Copyright 2007 The Closure Library Authors. All Rights Reserved.
2
//
3
// Licensed under the Apache License, Version 2.0 (the "License");
4
// you may not use this file except in compliance with the License.
5
// You may obtain a copy of the License at
6
//
7
//      http://www.apache.org/licenses/LICENSE-2.0
8
//
9
// Unless required by applicable law or agreed to in writing, software
10
// distributed under the License is distributed on an "AS-IS" BASIS,
11
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12
// See the License for the specific language governing permissions and
13
// limitations under the License.
14

15
/**
16
 * @fileoverview A utility class for managing editable links.
17
 *
18
 * @author [email protected] (Nick Santos)
19
 */
20

21
goog.provide('goog.editor.Link');
22

23
goog.require('goog.array');
24
goog.require('goog.dom');
25
goog.require('goog.dom.NodeType');
26
goog.require('goog.dom.Range');
27
goog.require('goog.dom.TagName');
28
goog.require('goog.editor.BrowserFeature');
29
goog.require('goog.editor.Command');
30
goog.require('goog.editor.Field');
31
goog.require('goog.editor.node');
32
goog.require('goog.editor.range');
33
goog.require('goog.string');
34
goog.require('goog.string.Unicode');
35
goog.require('goog.uri.utils');
36
goog.require('goog.uri.utils.ComponentIndex');
37

38

39

40
/**
41
 * Wrap an editable link.
42
 * @param {HTMLAnchorElement} anchor The anchor element.
43
 * @param {boolean} isNew Whether this is a new link.
44
 * @constructor
45
 * @final
46
 */
47
goog.editor.Link = function(anchor, isNew) {
48
  /**
49
   * The link DOM element.
50
   * @type {HTMLAnchorElement}
51
   * @private
52
   */
53
  this.anchor_ = anchor;
54

55
  /**
56
   * Whether this link represents a link just added to the document.
57
   * @type {boolean}
58
   * @private
59
   */
60
  this.isNew_ = isNew;
61

62

63
  /**
64
   * Any extra anchors created by the browser from a selection in the same
65
   * operation that created the primary link
66
   * @type {!Array<HTMLAnchorElement>}
67
   * @private
68
   */
69
  this.extraAnchors_ = [];
70
};
71

72

73
/**
74
 * @return {HTMLAnchorElement} The anchor element.
75
 */
76
goog.editor.Link.prototype.getAnchor = function() {
77
  return this.anchor_;
78
};
79

80

81
/**
82
 * @return {!Array<HTMLAnchorElement>} The extra anchor elements, if any,
83
 *     created by the browser from a selection.
84
 */
85
goog.editor.Link.prototype.getExtraAnchors = function() {
86
  return this.extraAnchors_;
87
};
88

89

90
/**
91
 * @return {string} The inner text for the anchor.
92
 */
93
goog.editor.Link.prototype.getCurrentText = function() {
94
  if (!this.currentText_) {
95
    var anchor = this.getAnchor();
96

97
    var leaf = goog.editor.node.getLeftMostLeaf(anchor);
98
    if (leaf.tagName && leaf.tagName == goog.dom.TagName.IMG) {
99
      this.currentText_ = leaf.getAttribute('alt');
100
    } else {
101
      this.currentText_ = goog.dom.getRawTextContent(this.getAnchor());
102
    }
103
  }
104
  return this.currentText_;
105
};
106

107

108
/**
109
 * @return {boolean} Whether the link is new.
110
 */
111
goog.editor.Link.prototype.isNew = function() {
112
  return this.isNew_;
113
};
114

115

116
/**
117
 * Set the url without affecting the isNew() status of the link.
118
 * @param {string} url A URL.
119
 */
120
goog.editor.Link.prototype.initializeUrl = function(url) {
121
  this.getAnchor().href = url;
122
};
123

124

125
/**
126
 * Removes the link, leaving its contents in the document.  Note that this
127
 * object will no longer be usable/useful after this call.
128
 */
129
goog.editor.Link.prototype.removeLink = function() {
130
  goog.dom.flattenElement(this.anchor_);
131
  this.anchor_ = null;
132
  while (this.extraAnchors_.length) {
133
    goog.dom.flattenElement(/** @type {Element} */ (this.extraAnchors_.pop()));
134
  }
135
};
136

137

138
/**
139
 * Change the link.
140
 * @param {string} newText New text for the link. If the link contains all its
141
 *     text in one descendent, newText will only replace the text in that
142
 *     one node. Otherwise, we'll change the innerHTML of the whole
143
 *     link to newText.
144
 * @param {string} newUrl A new URL.
145
 */
146
goog.editor.Link.prototype.setTextAndUrl = function(newText, newUrl) {
147
  var anchor = this.getAnchor();
148
  anchor.href = newUrl;
149

150
  // If the text did not change, don't update link text.
151
  var currentText = this.getCurrentText();
152
  if (newText != currentText) {
153
    var leaf = goog.editor.node.getLeftMostLeaf(anchor);
154

155
    if (leaf.tagName && leaf.tagName == goog.dom.TagName.IMG) {
156
      leaf.setAttribute('alt', newText ? newText : '');
157
    } else {
158
      if (leaf.nodeType == goog.dom.NodeType.TEXT) {
159
        leaf = leaf.parentNode;
160
      }
161

162
      if (goog.dom.getRawTextContent(leaf) != currentText) {
163
        leaf = anchor;
164
      }
165

166
      goog.dom.removeChildren(leaf);
167
      var domHelper = goog.dom.getDomHelper(leaf);
168
      goog.dom.appendChild(leaf, domHelper.createTextNode(newText));
169
    }
170

171
    // The text changed, so force getCurrentText to recompute.
172
    this.currentText_ = null;
173
  }
174

175
  this.isNew_ = false;
176
};
177

178

179
/**
180
 * Places the cursor to the right of the anchor.
181
 * Note that this is different from goog.editor.range's placeCursorNextTo
182
 * in that it specifically handles the placement of a cursor in browsers
183
 * that trap you in links, by adding a space when necessary and placing the
184
 * cursor after that space.
185
 */
186
goog.editor.Link.prototype.placeCursorRightOf = function() {
187
  var anchor = this.getAnchor();
188
  // If the browser gets stuck in a link if we place the cursor next to it,
189
  // we'll place the cursor after a space instead.
190
  if (goog.editor.BrowserFeature.GETS_STUCK_IN_LINKS) {
191
    var spaceNode;
192
    var nextSibling = anchor.nextSibling;
193

194
    // Check if there is already a space after the link.  Only handle the
195
    // simple case - the next node is a text node that starts with a space.
196
    if (nextSibling && nextSibling.nodeType == goog.dom.NodeType.TEXT &&
197
        (goog.string.startsWith(nextSibling.data, goog.string.Unicode.NBSP) ||
198
         goog.string.startsWith(nextSibling.data, ' '))) {
199
      spaceNode = nextSibling;
200
    } else {
201
      // If there isn't an obvious space to use, create one after the link.
202
      var dh = goog.dom.getDomHelper(anchor);
203
      spaceNode = dh.createTextNode(goog.string.Unicode.NBSP);
204
      goog.dom.insertSiblingAfter(spaceNode, anchor);
205
    }
206

207
    // Move the selection after the space.
208
    var range = goog.dom.Range.createCaret(spaceNode, 1);
209
    range.select();
210
  } else {
211
    goog.editor.range.placeCursorNextTo(anchor, false);
212
  }
213
};
214

215

216
/**
217
 * Updates the cursor position and link bubble for this link.
218
 * @param {goog.editor.Field} field The field in which the link is created.
219
 * @param {string} url The link url.
220
 * @private
221
 */
222
goog.editor.Link.prototype.updateLinkDisplay_ = function(field, url) {
223
  this.initializeUrl(url);
224
  this.placeCursorRightOf();
225
  field.execCommand(goog.editor.Command.UPDATE_LINK_BUBBLE);
226
};
227

228

229
/**
230
 * @return {string?} The modified string for the link if the link
231
 *     text appears to be a valid link. Returns null if this is not
232
 *     a valid link address.
233
 */
234
goog.editor.Link.prototype.getValidLinkFromText = function() {
235
  var text = goog.string.trim(this.getCurrentText());
236
  if (goog.editor.Link.isLikelyUrl(text)) {
237
    if (text.search(/:/) < 0) {
238
      return 'http://' + goog.string.trimLeft(text);
239
    }
240
    return text;
241
  } else if (goog.editor.Link.isLikelyEmailAddress(text)) {
242
    return 'mailto:' + text;
243
  }
244
  return null;
245
};
246

247

248
/**
249
 * After link creation, finish creating the link depending on the type
250
 * of link being created.
251
 * @param {goog.editor.Field} field The field where this link is being created.
252
 */
253
goog.editor.Link.prototype.finishLinkCreation = function(field) {
254
  var linkFromText = this.getValidLinkFromText();
255
  if (linkFromText) {
256
    this.updateLinkDisplay_(field, linkFromText);
257
  } else {
258
    field.execCommand(goog.editor.Command.MODAL_LINK_EDITOR, this);
259
  }
260
};
261

262

263
/**
264
 * Initialize a new link.
265
 * @param {HTMLAnchorElement} anchor The anchor element.
266
 * @param {string} url The initial URL.
267
 * @param {string=} opt_target The target.
268
 * @param {Array<HTMLAnchorElement>=} opt_extraAnchors Extra anchors created
269
 *     by the browser when parsing a selection.
270
 * @return {!goog.editor.Link} The link.
271
 */
272
goog.editor.Link.createNewLink = function(
273
    anchor, url, opt_target, opt_extraAnchors) {
274
  var link = new goog.editor.Link(anchor, true);
275
  link.initializeUrl(url);
276

277
  if (opt_target) {
278
    anchor.target = opt_target;
279
  }
280
  if (opt_extraAnchors) {
281
    link.extraAnchors_ = opt_extraAnchors;
282
  }
283

284
  return link;
285
};
286

287

288
/**
289
 * Initialize a new link using text in anchor, or empty string if there is no
290
 * likely url in the anchor.
291
 * @param {HTMLAnchorElement} anchor The anchor element with likely url content.
292
 * @param {string=} opt_target The target.
293
 * @return {!goog.editor.Link} The link.
294
 */
295
goog.editor.Link.createNewLinkFromText = function(anchor, opt_target) {
296
  var link = new goog.editor.Link(anchor, true);
297
  var text = link.getValidLinkFromText();
298
  link.initializeUrl(text ? text : '');
299
  if (opt_target) {
300
    anchor.target = opt_target;
301
  }
302
  return link;
303
};
304

305

306
/**
307
 * Returns true if str could be a URL, false otherwise
308
 *
309
 * Ex: TR_Util.isLikelyUrl_("http://www.google.com") == true
310
 *     TR_Util.isLikelyUrl_("www.google.com") == true
311
 *
312
 * @param {string} str String to check if it looks like a URL.
313
 * @return {boolean} Whether str could be a URL.
314
 */
315
goog.editor.Link.isLikelyUrl = function(str) {
316
  // Whitespace means this isn't a domain.
317
  if (/\s/.test(str)) {
318
    return false;
319
  }
320

321
  if (goog.editor.Link.isLikelyEmailAddress(str)) {
322
    return false;
323
  }
324

325
  // Add a scheme if the url doesn't have one - this helps the parser.
326
  var addedScheme = false;
327
  if (!/^[^:\/?#.]+:/.test(str)) {
328
    str = 'http://' + str;
329
    addedScheme = true;
330
  }
331

332
  // Parse the domain.
333
  var parts = goog.uri.utils.split(str);
334

335
  // Relax the rules for special schemes.
336
  var scheme = parts[goog.uri.utils.ComponentIndex.SCHEME];
337
  if (goog.array.indexOf(['mailto', 'aim'], scheme) != -1) {
338
    return true;
339
  }
340

341
  // Require domains to contain a '.', unless the domain is fully qualified and
342
  // forbids domains from containing invalid characters.
343
  var domain = parts[goog.uri.utils.ComponentIndex.DOMAIN];
344
  if (!domain || (addedScheme && domain.indexOf('.') == -1) ||
345
      (/[^\w\d\-\u0100-\uffff.%]/.test(domain))) {
346
    return false;
347
  }
348

349
  // Require http and ftp paths to start with '/'.
350
  var path = parts[goog.uri.utils.ComponentIndex.PATH];
351
  return !path || path.indexOf('/') == 0;
352
};
353

354

355
/**
356
 * Regular expression that matches strings that could be an email address.
357
 * @type {RegExp}
358
 * @private
359
 */
360
goog.editor.Link.LIKELY_EMAIL_ADDRESS_ = new RegExp(
361
    '^' +                         // Test from start of string
362
        '[\\w-]+(\\.[\\w-]+)*' +  // Dot-delimited alphanumerics and dashes
363
                                  // (name)
364
        '\\@' +                   // @
365
        '([\\w-]+\\.)+' +         // Alphanumerics, dashes and dots (domain)
366
        '(\\d+|\\w\\w+)$',  // Domain ends in at least one number or 2 letters
367
    'i');
368

369

370
/**
371
 * Returns true if str could be an email address, false otherwise
372
 *
373
 * Ex: goog.editor.Link.isLikelyEmailAddress_("some word") == false
374
 *     goog.editor.Link.isLikelyEmailAddress_("[email protected]") == true
375
 *
376
 * @param {string} str String to test for being email address.
377
 * @return {boolean} Whether "str" looks like an email address.
378
 */
379
goog.editor.Link.isLikelyEmailAddress = function(str) {
380
  return goog.editor.Link.LIKELY_EMAIL_ADDRESS_.test(str);
381
};
382

383

384
/**
385
 * Determines whether or not a url is an email link.
386
 * @param {string} url A url.
387
 * @return {boolean} Whether the url is a mailto link.
388
 */
389
goog.editor.Link.isMailto = function(url) {
390
  return !!url && goog.string.startsWith(url, 'mailto:');
391
};
392

393