experiments in a post-browser web
first commit
+2879
+5
README.md
+5
README.md
+10
data/content.js
+10
data/content.js
+4
data/panel.js
+4
data/panel.js
+2
doc/main.md
+2
doc/main.md
+167
lib/main.js
+167
lib/main.js
···
1
+
/*
2
+
3
+
The new app tab feature in Firefox is great. I use it a lot... which has shown starkly how apps and tabs have completely different use-cases and usage patterns. Often I will check my Gmail app tab because I see the glowing notification that a new email has arrived, do something (or nothing), and then pop back to where I was browsing - in one of those 78 tabs I have open. Well, not "pop" really.
4
+
5
+
The windowing model in operating systems allows me to do this with ease. But app tabs do not:
6
+
7
+
* If I opened no new tabs while using Gmail, I can still see the last tab I was at, and click on it. But I'm force to use the mouse.
8
+
* Out of sheer muscle memory and mouse-averseness, sometimes I can traverse tabs via the next/previous-tab keyboard shortcuts to get back to where I was. Sometimes it's a *lot* of tabs, so either I'll hold the arrow key down, speeding past the tab I wanted, or I'll just hit that arrow key a bunch of times in quick succession. Both options are sub-optimal.
9
+
* Or I have to expend mental energy to search in the awesomebar and switch to that tab, which often looks like this: "hm, type 'bug' and then try to remember some words in the bug summary, but those words match a bunch of other bugs, and i don't know the bug number, and also I'm on an attachment page because I'm reviewing a patch on the bug, so the summary won't be in the page title..." and on and on.
10
+
* Then there's link opening. Links opened in app tabs are put at the beginning of the tab set, and the tab strip is animatedly scrolled there. Boom, already lost where I was before checking my email. We tried an experiment where they open at the end of the set of open tabs, but I found that to have serious "out of sight, out of mind" problems. That experiment was rolled back. Both approaches cause excess amounts of whizzing animations, either when you want to "go around the horn" to get to the tabs you just opened from app tabs, or when you want to go to them and then get back to where you were.
11
+
* And the biggest problem in my opinion: The user is not in control of where these links are opened. Part of me thinks that I actually might work best in a one-tab-group-per-app-tab world... but that's a vision for another day (and blog post and add-on!).
12
+
13
+
14
+
So I've tried to build a hybrid solution: Instead of making you go to your app tabs, your app tabs can come to you. Peek allows you to open your app tabs in a floating panel that opens on top of wherever you are in your tabs. Links open to the right of whatever your current active tab is, and in the background, so that when you're done peeking, you are exactly where you left off.
15
+
16
+
To use Peek, first create some app tabs. Then you can peek at them using the keyboard shortcut "ALT+SHIFT+1-9" where the number corresponds with the order your app tabs are in. To stop peeking, hit escape (or switch apps or anything else that takes focus away from the panel).
17
+
18
+
Features:
19
+
- be able to interact with your apps and go exactly back to where you left off browsing.
20
+
- links opened from app tabs are in context of... well, at least something! not at beginning or end of tabstrip, which gives you at least more control over where they end up.
21
+
22
+
*/
23
+
24
+
/*
25
+
TODO
26
+
- add a UI launcher somehow (drop button?)
27
+
- remove pinned tabs altogether!
28
+
*/
29
+
30
+
const {Cc, Ci, Cu, Cm} = require('chrome');
31
+
const { Hotkey } = require('hotkeys');
32
+
const { Panel } = require('panel-custom-frame');
33
+
const Data = require('self').data;
34
+
const Observers = require('observer-service');
35
+
const Prefs = require('preferences-service');
36
+
const Tabs = require('tabs');
37
+
const Timers = require('timer');
38
+
const Windows = require('windows').browserWindows;
39
+
const WinUtils = require("window-utils");
40
+
41
+
const TAB_PREF = 'browser.tabs.loadDivertedInBackground';
42
+
const COMBO = 'alt-shift-';
43
+
44
+
// 5 minutes
45
+
const INTERVAL = 1000 * 60 * 5;
46
+
47
+
let inited,
48
+
lastPrefVal,
49
+
cache = [],
50
+
windowHeight,
51
+
windowWidth;
52
+
53
+
function getPanel() {
54
+
let panel = Panel({
55
+
contentURL: 'about:blank',
56
+
height: getPanelDimension(windowHeight),
57
+
width: getPanelDimension(windowWidth),
58
+
contentScriptFile: Data.url('panel.js'),
59
+
contentScriptWhen: 'ready',
60
+
onShow: function() {
61
+
lastPrefVal = Prefs.get(TAB_PREF);
62
+
if (!lastPrefVal)
63
+
Prefs.set(TAB_PREF, true);
64
+
},
65
+
onHide: function() {
66
+
if (lastPrefVal != Prefs.get(TAB_PREF))
67
+
Prefs.set(TAB_PREF, lastPrefVal);
68
+
}
69
+
});
70
+
return panel;
71
+
}
72
+
73
+
function getPanelDimension(amount) Math.round(amount * 0.9)
74
+
75
+
// Build and cache hotkey+panels for each app tab
76
+
function setup() {
77
+
// destroy existing hotkey+panel combos
78
+
cache.forEach(function(hotkey) {
79
+
hotkey.destroy();
80
+
});
81
+
cache = [];
82
+
83
+
for (var i = 0; i < 10; i++) {
84
+
var jetpackTab = Windows.activeWindow.tabs[i];
85
+
if (jetpackTab && jetpackTab.isPinned) {
86
+
let index = jetpackTab.index;
87
+
let hotkeyNum = index == 9 ? 0 : (index + 1);
88
+
let hotkey = Hotkey({
89
+
// WTF - setting this to typo'd 'hotkeynum' doesn't throw!
90
+
combo: (COMBO + hotkeyNum),
91
+
onPress: function() {
92
+
console.log('onPress(): index ', index);
93
+
let panel = getPanel();
94
+
//let oldFrame = panel.frame;
95
+
//console.log('onPress(): oldFrame ', frame);
96
+
let tabbrowser = WinUtils.activeBrowserWindow.gBrowser;
97
+
let frame = tabbrowser.getBrowserAtIndex(index);
98
+
console.log('onPress(): frame ', frame.currentURI.spec);
99
+
panel.frame = frame;
100
+
console.log('onPress(): new frame uri ', panel.frame.currentURI.spec);
101
+
// need to support switching while panel is open
102
+
panel.on('hide', function() {
103
+
panel.frame = null;
104
+
panel.destroy();
105
+
});
106
+
panel.show();
107
+
console.log('onPress(): done');
108
+
}
109
+
});
110
+
111
+
cache[i] = hotkey;
112
+
}
113
+
}
114
+
}
115
+
116
+
// Window resize event handler
117
+
function onResize(msg) {
118
+
windowHeight = msg.height;
119
+
windowWidth = msg.width;
120
+
121
+
// Initializing on the first received resize event ensures
122
+
// that it occurs for both running and startup installs.
123
+
if (!inited) {
124
+
setup();
125
+
inited = true;
126
+
}
127
+
}
128
+
129
+
// When a tab activates, attach our content script
130
+
// and remove when deactivated. Content script is for:
131
+
// - getting window size
132
+
function onTabActivate(tab) {
133
+
let worker = tab.attach({
134
+
contentScriptFile: Data.url('content.js'),
135
+
contentScriptWhen: 'ready'
136
+
});
137
+
worker.port.on('resize', onResize);
138
+
tab.on('deactivate', function(tab) {
139
+
worker.destroy();
140
+
});
141
+
}
142
+
143
+
// Handle current tab activation manually in case we're installed
144
+
// in a running instance. This gets us initial window size which
145
+
// triggers initial filling of cache.
146
+
onTabActivate(Tabs.activeTab);
147
+
148
+
// Listen for tab switching
149
+
Tabs.on('activate', onTabActivate);
150
+
151
+
let delegate = {
152
+
onTrack: function (window) {
153
+
if (window.document.documentElement.getAttribute('windowtype') == 'navigator:browser') {
154
+
let container = window.gBrowser.tabContainer;
155
+
container.addEventListener("TabPinned", setup, false);
156
+
container.addEventListener("TabUnpinned", setup, false);
157
+
}
158
+
},
159
+
onUntrack: function (window) {
160
+
if (window.document.documentElement.getAttribute('windowtype') == 'navigator:browser') {
161
+
let container = window.gBrowser.tabContainer;
162
+
container.removeEventListener("TabPinned", setup, false);
163
+
container.removeEventListener("TabUnpinned", setup, false);
164
+
}
165
+
}
166
+
};
167
+
new WinUtils.WindowTracker(delegate);
+380
lib/panel-custom-frame.js
+380
lib/panel-custom-frame.js
···
1
+
/* This Source Code Form is subject to the terms of the Mozilla Public
2
+
* License, v. 2.0. If a copy of the MPL was not distributed with this
3
+
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
4
+
5
+
"use strict";
6
+
7
+
if (!require("api-utils/xul-app").is("Firefox")) {
8
+
throw new Error([
9
+
"The panel module currently supports only Firefox. In the future ",
10
+
"we would like it to support other applications, however. Please see ",
11
+
"https://bugzilla.mozilla.org/show_bug.cgi?id=jetpack-panel-apps ",
12
+
"for more information."
13
+
].join(""));
14
+
}
15
+
16
+
const { Cc, Ci } = require("chrome");
17
+
18
+
const { validateOptions: valid } = require("api-utils/api-utils");
19
+
const { Symbiont } = require("api-utils/content");
20
+
const { EventEmitter } = require('api-utils/events');
21
+
const timer = require("api-utils/timer");
22
+
const runtime = require("api-utils/runtime");
23
+
24
+
const windowMediator = Cc['@mozilla.org/appshell/window-mediator;1'].
25
+
getService(Ci.nsIWindowMediator);
26
+
27
+
const XUL_NS = "http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul",
28
+
ON_SHOW = 'popupshown',
29
+
ON_HIDE = 'popuphidden',
30
+
validNumber = { is: ['number', 'undefined', 'null'] };
31
+
32
+
/**
33
+
* Emits show and hide events.
34
+
*/
35
+
const Panel = Symbiont.resolve({
36
+
constructor: '_init',
37
+
_onInit: '_onSymbiontInit',
38
+
destroy: '_symbiontDestructor',
39
+
_documentUnload: '_workerDocumentUnload'
40
+
}).compose({
41
+
_frame: Symbiont.required,
42
+
_init: Symbiont.required,
43
+
_onSymbiontInit: Symbiont.required,
44
+
_symbiontDestructor: Symbiont.required,
45
+
_emit: Symbiont.required,
46
+
_asyncEmit: Symbiont.required,
47
+
on: Symbiont.required,
48
+
removeListener: Symbiont.required,
49
+
50
+
_inited: false,
51
+
52
+
/**
53
+
* If set to `true` frame loaders between xul panel frame and
54
+
* hidden frame are swapped. If set to `false` frame loaders are
55
+
* set back to normal. Setting the value that was already set will
56
+
* have no effect.
57
+
*/
58
+
set _frameLoadersSwapped(value) {
59
+
if (this.__frameLoadersSwapped == value) return;
60
+
console.log('swapping fls, frame: ', this._frame);
61
+
//console.log('uri:', this._frame.currentURI.spec);
62
+
this._frame.QueryInterface(Ci.nsIFrameLoaderOwner)
63
+
.swapFrameLoaders(this._viewFrame);
64
+
this.__frameLoadersSwapped = value;
65
+
},
66
+
__frameLoadersSwapped: false,
67
+
68
+
constructor: function Panel(options) {
69
+
this._onShow = this._onShow.bind(this);
70
+
this._onHide = this._onHide.bind(this);
71
+
this.on('inited', this._onSymbiontInit.bind(this));
72
+
73
+
options = options || {};
74
+
if ('onShow' in options)
75
+
this.on('show', options.onShow);
76
+
if ('onHide' in options)
77
+
this.on('hide', options.onHide);
78
+
if ('width' in options)
79
+
this.width = options.width;
80
+
if ('height' in options)
81
+
this.height = options.height;
82
+
if ('contentURL' in options)
83
+
this.contentURL = options.contentURL;
84
+
85
+
this._init(options);
86
+
},
87
+
_destructor: function _destructor() {
88
+
this.hide();
89
+
this._removeAllListeners('show');
90
+
// defer cleanup to be performed after panel gets hidden
91
+
this._xulPanel = null;
92
+
this._symbiontDestructor(this);
93
+
this._removeAllListeners();
94
+
},
95
+
destroy: function destroy() {
96
+
this._destructor();
97
+
},
98
+
/* Public API: Panel.width */
99
+
get width() this._width,
100
+
set width(value)
101
+
this._width = valid({ $: value }, { $: validNumber }).$ || this._width,
102
+
_width: 320,
103
+
/* Public API: Panel.height */
104
+
get height() this._height,
105
+
set height(value)
106
+
this._height = valid({ $: value }, { $: validNumber }).$ || this._height,
107
+
_height: 240,
108
+
109
+
get frame() this._frame,
110
+
set frame(value) {
111
+
console.log('set frame(): ', value);
112
+
this._frame = value;
113
+
},
114
+
115
+
/* Public API: Panel.isShowing */
116
+
get isShowing() !!this._xulPanel && this._xulPanel.state == "open",
117
+
118
+
/* Public API: Panel.show */
119
+
show: function show(anchor) {
120
+
anchor = anchor || null;
121
+
let document = getWindow(anchor).document;
122
+
let xulPanel = this._xulPanel;
123
+
if (!xulPanel) {
124
+
xulPanel = this._xulPanel = document.createElementNS(XUL_NS, 'panel');
125
+
xulPanel.setAttribute("type", "arrow");
126
+
127
+
// One anonymous node has a big padding that doesn't work well with
128
+
// Jetpack, as we would like to display an iframe that completely fills
129
+
// the panel.
130
+
// -> Use a XBL wrapper with inner stylesheet to remove this padding.
131
+
let css = ".panel-inner-arrowcontent, .panel-arrowcontent {padding: 0;}";
132
+
let originalXBL = "chrome://global/content/bindings/popup.xml#arrowpanel";
133
+
let binding =
134
+
'<bindings xmlns="http://www.mozilla.org/xbl">' +
135
+
'<binding id="id" extends="' + originalXBL + '">' +
136
+
'<resources>' +
137
+
'<stylesheet src="data:text/css,' +
138
+
document.defaultView.encodeURIComponent(css) + '"/>' +
139
+
'</resources>' +
140
+
'</binding>' +
141
+
'</bindings>';
142
+
xulPanel.style.MozBinding = 'url("data:text/xml,' +
143
+
document.defaultView.encodeURIComponent(binding) + '")';
144
+
145
+
let frame = document.createElementNS(XUL_NS, 'iframe');
146
+
frame.setAttribute('type', 'content');
147
+
frame.setAttribute('flex', '1');
148
+
frame.setAttribute('transparent', 'transparent');
149
+
if (runtime.OS === "Darwin") {
150
+
frame.style.borderRadius = "6px";
151
+
frame.style.padding = "1px";
152
+
}
153
+
154
+
// Load an empty document in order to have an immediatly loaded iframe,
155
+
// so swapFrameLoaders is going to work without having to wait for load.
156
+
frame.setAttribute("src","data:,");
157
+
158
+
xulPanel.appendChild(frame);
159
+
document.getElementById("mainPopupSet").appendChild(xulPanel);
160
+
}
161
+
let { width, height } = this, x, y, position;
162
+
163
+
if (!anchor) {
164
+
// Open the popup in the middle of the window.
165
+
x = document.documentElement.clientWidth / 2 - width / 2;
166
+
y = document.documentElement.clientHeight / 2 - height / 2;
167
+
position = null;
168
+
}
169
+
else {
170
+
// Open the popup by the anchor.
171
+
let rect = anchor.getBoundingClientRect();
172
+
173
+
let window = anchor.ownerDocument.defaultView;
174
+
175
+
let zoom = window.mozScreenPixelsPerCSSPixel;
176
+
let screenX = rect.left + window.mozInnerScreenX * zoom;
177
+
let screenY = rect.top + window.mozInnerScreenY * zoom;
178
+
179
+
// Set up the vertical position of the popup relative to the anchor
180
+
// (always display the arrow on anchor center)
181
+
let horizontal, vertical;
182
+
if (screenY > window.screen.availHeight / 2 + height)
183
+
vertical = "top";
184
+
else
185
+
vertical = "bottom";
186
+
187
+
if (screenY > window.screen.availWidth / 2 + width)
188
+
horizontal = "left";
189
+
else
190
+
horizontal = "right";
191
+
192
+
let verticalInverse = vertical == "top" ? "bottom" : "top";
193
+
position = vertical + "center " + verticalInverse + horizontal;
194
+
195
+
// Allow panel to flip itself if the panel can't be displayed at the
196
+
// specified position (useful if we compute a bad position or if the
197
+
// user moves the window and panel remains visible)
198
+
xulPanel.setAttribute("flip","both");
199
+
}
200
+
201
+
// Resize the iframe instead of using panel.sizeTo
202
+
// because sizeTo doesn't work with arrow panels
203
+
xulPanel.firstChild.style.width = width + "px";
204
+
xulPanel.firstChild.style.height = height + "px";
205
+
206
+
// Wait for the XBL binding to be constructed
207
+
function waitForBinding() {
208
+
if (!xulPanel.openPopup) {
209
+
timer.setTimeout(waitForBinding, 50);
210
+
return;
211
+
}
212
+
xulPanel.openPopup(anchor, position, x, y);
213
+
}
214
+
waitForBinding();
215
+
216
+
return this._public;
217
+
},
218
+
/* Public API: Panel.hide */
219
+
hide: function hide() {
220
+
// The popuphiding handler takes care of swapping back the frame loaders
221
+
// and removing the XUL panel from the application window, we just have to
222
+
// trigger it by hiding the popup.
223
+
// XXX Sometimes I get "TypeError: xulPanel.hidePopup is not a function"
224
+
// when quitting the host application while a panel is visible. To suppress
225
+
// them, this now checks for "hidePopup" in xulPanel before calling it.
226
+
// It's not clear if there's an actual issue or the error is just normal.
227
+
let xulPanel = this._xulPanel;
228
+
if (xulPanel && "hidePopup" in xulPanel)
229
+
xulPanel.hidePopup();
230
+
return this._public;
231
+
},
232
+
233
+
/* Public API: Panel.resize */
234
+
resize: function resize(width, height) {
235
+
this.width = width;
236
+
this.height = height;
237
+
// Resize the iframe instead of using panel.sizeTo
238
+
// because sizeTo doesn't work with arrow panels
239
+
let xulPanel = this._xulPanel;
240
+
if (xulPanel) {
241
+
xulPanel.firstChild.style.width = width + "px";
242
+
xulPanel.firstChild.style.height = height + "px";
243
+
}
244
+
},
245
+
246
+
// While the panel is visible, this is the XUL <panel> we use to display it.
247
+
// Otherwise, it's null.
248
+
get _xulPanel() this.__xulPanel,
249
+
set _xulPanel(value) {
250
+
let xulPanel = this.__xulPanel;
251
+
if (value === xulPanel) return;
252
+
if (xulPanel) {
253
+
xulPanel.removeEventListener(ON_HIDE, this._onHide, false);
254
+
xulPanel.removeEventListener(ON_SHOW, this._onShow, false);
255
+
xulPanel.parentNode.removeChild(xulPanel);
256
+
}
257
+
if (value) {
258
+
value.addEventListener(ON_HIDE, this._onHide, false);
259
+
value.addEventListener(ON_SHOW, this._onShow, false);
260
+
}
261
+
this.__xulPanel = value;
262
+
},
263
+
__xulPanel: null,
264
+
get _viewFrame() this.__xulPanel.children[0],
265
+
/**
266
+
* When the XUL panel becomes hidden, we swap frame loaders back to move
267
+
* the content of the panel to the hidden frame & remove panel element.
268
+
*/
269
+
_onHide: function _onHide() {
270
+
try {
271
+
this._frameLoadersSwapped = false;
272
+
this._xulPanel = null;
273
+
this._emit('hide');
274
+
} catch(e) {
275
+
this._emit('error', e);
276
+
}
277
+
},
278
+
/**
279
+
* When the XUL panel becomes shown, we swap frame loaders between panel
280
+
* frame and hidden frame to preserve state of the content dom.
281
+
*/
282
+
_onShow: function _onShow() {
283
+
try {
284
+
if (!this._inited) { // defer if not initialized yet
285
+
this.on('inited', this._onShow.bind(this));
286
+
} else {
287
+
console.log('_onShow(): frame', typeof this._frame);
288
+
//console.log('_onShow(): ', this._frame.currentURI.spec);
289
+
//this._frameLoadersSwapped.bind(this);
290
+
this._frameLoadersSwapped = true;
291
+
292
+
// Retrieve computed text color style in order to apply to the iframe
293
+
// document. As MacOS background is dark gray, we need to use skin's
294
+
// text color.
295
+
let win = this._xulPanel.ownerDocument.defaultView;
296
+
let node = win.document.getAnonymousElementByAttribute(this._xulPanel,
297
+
"class", "panel-inner-arrowcontent");
298
+
let textColor = win.getComputedStyle(node).getPropertyValue("color");
299
+
let doc = this._xulPanel.firstChild.contentDocument;
300
+
let style = doc.createElement("style");
301
+
style.textContent = "body { color: " + textColor + "; }";
302
+
let container = doc.head ? doc.head : doc.documentElement;
303
+
304
+
if (container.firstChild)
305
+
container.insertBefore(style, container.firstChild);
306
+
else
307
+
container.appendChild(style);
308
+
309
+
this._emit('show');
310
+
}
311
+
} catch(e) {
312
+
this._emit('error', e);
313
+
}
314
+
},
315
+
/**
316
+
* Notification that panel was fully initialized.
317
+
*/
318
+
_onInit: function _onInit() {
319
+
this._inited = true;
320
+
321
+
// Avoid panel document from resizing the browser window
322
+
// New platform capability added through bug 635673
323
+
if ("allowWindowControl" in this._frame.docShell)
324
+
this._frame.docShell.allowWindowControl = false;
325
+
326
+
// perform all deferred tasks like initSymbiont, show, hide ...
327
+
// TODO: We're publicly exposing a private event here; this
328
+
// 'inited' event should really be made private, somehow.
329
+
this._emit('inited');
330
+
},
331
+
332
+
// Catch document unload event in order to rebind load event listener with
333
+
// Symbiont._initFrame if Worker._documentUnload destroyed the worker
334
+
_documentUnload: function(subject, topic, data) {
335
+
if (this._workerDocumentUnload(subject, topic, data)) {
336
+
this._initFrame(this._frame);
337
+
return true;
338
+
}
339
+
return false;
340
+
}
341
+
});
342
+
exports.Panel = function(options) Panel(options)
343
+
exports.Panel.prototype = Panel.prototype;
344
+
345
+
function getWindow(anchor) {
346
+
let window;
347
+
348
+
if (anchor) {
349
+
let anchorWindow = anchor.ownerDocument.defaultView.top;
350
+
let anchorDocument = anchorWindow.document;
351
+
352
+
let enumerator = windowMediator.getEnumerator("navigator:browser");
353
+
while (enumerator.hasMoreElements()) {
354
+
let enumWindow = enumerator.getNext();
355
+
356
+
// Check if the anchor is in this browser window.
357
+
if (enumWindow == anchorWindow) {
358
+
window = anchorWindow;
359
+
break;
360
+
}
361
+
362
+
// Check if the anchor is in a browser tab in this browser window.
363
+
let browser = enumWindow.gBrowser.getBrowserForDocument(anchorDocument);
364
+
if (browser) {
365
+
window = enumWindow;
366
+
break;
367
+
}
368
+
369
+
// Look in other subdocuments (sidebar, etc.)?
370
+
}
371
+
}
372
+
373
+
// If we didn't find the anchor's window (or we have no anchor),
374
+
// return the most recent browser window.
375
+
if (!window)
376
+
window = windowMediator.getMostRecentWindow("navigator:browser");
377
+
378
+
return window;
379
+
}
380
+
+2270
lib/places.js
+2270
lib/places.js
···
1
+
/* -*- Mode: Java; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
2
+
/* vim:set ts=2 sw=2 sts=2 et: */
3
+
/* ***** BEGIN LICENSE BLOCK *****
4
+
* Version: MPL 1.1/GPL 2.0/LGPL 2.1
5
+
*
6
+
* The contents of this file are subject to the Mozilla Public License Version
7
+
* 1.1 (the "License"); you may not use this file except in compliance with
8
+
* the License. You may obtain a copy of the License at
9
+
* http://www.mozilla.org/MPL/
10
+
*
11
+
* Software distributed under the License is distributed on an "AS IS" basis,
12
+
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
13
+
* for the specific language governing rights and limitations under the
14
+
* License.
15
+
*
16
+
* The Original Code is Jetpack.
17
+
*
18
+
* The Initial Developer of the Original Code is the Mozilla Foundation.
19
+
* Portions created by the Initial Developer are Copyright (C) 2010
20
+
* the Initial Developer. All Rights Reserved.
21
+
*
22
+
* Contributor(s):
23
+
* Marco Bonardo <mak77@bonardo.net> (Original Author)
24
+
*
25
+
* Alternatively, the contents of this file may be used under the terms of
26
+
* either the GNU General Public License Version 2 or later (the "GPL"), or
27
+
* the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
28
+
* in which case the provisions of the GPL or the LGPL are applicable instead
29
+
* of those above. If you wish to allow use of your version of this file only
30
+
* under the terms of either the GPL or the LGPL, and not to allow others to
31
+
* use your version of this file under the terms of the MPL, indicate your
32
+
* decision by deleting the provisions above and replace them with the notice
33
+
* and other provisions required by the GPL or the LGPL. If you do not delete
34
+
* the provisions above, a recipient may use your version of this file under
35
+
* the terms of any one of the MPL, the GPL or the LGPL.
36
+
*
37
+
* ***** END LICENSE BLOCK ***** */
38
+
39
+
const {Cc, Ci, Cr, Cu} = require("chrome");
40
+
41
+
// PlacesQuery is currently included at the bottom of this file,
42
+
// to ease distribution by not tying Jetpack's usage of it to a
43
+
// particular Firefox version.
44
+
//Cu.import("resource://gre/modules/PlacesQuery.jsm", this);
45
+
Cu.import("resource://gre/modules/PlacesUtils.jsm", this);
46
+
47
+
const apiUtils = require("api-utils");
48
+
const collection = require("collection");
49
+
const errors = require("errors");
50
+
51
+
52
+
// Main search function.
53
+
exports.search = (new PlacesHandler()).search;
54
+
55
+
56
+
// Shortcut helper to search visited places.
57
+
exports.history = new PlacesHandler({ visited: {} });
58
+
// Shortcut helper to search bookmarked places.
59
+
exports.bookmarks = new PlacesHandler({ bookmarked: {} });
60
+
61
+
62
+
// Add bookmark root folder shortcuts.
63
+
exports.bookmarks.unfiled = PlacesUtils.unfiledBookmarksFolderId;
64
+
exports.bookmarks.toolbar = PlacesUtils.toolbarFolderId;
65
+
exports.bookmarks.menu = PlacesUtils.bookmarksMenuFolderId;
66
+
67
+
68
+
// Method for creating a bookmark. Can take an options object or an array of
69
+
// options objects to create bookmarks in batch.
70
+
exports.bookmarks.create = function PF_create(aOptions) {
71
+
let options = validateBookmarkInfo(aOptions, true);
72
+
73
+
let bs = PlacesUtils.bookmarks;
74
+
75
+
// Create the bookmark item.
76
+
try {
77
+
switch(options.type) {
78
+
case "bookmark":
79
+
options._itemId =
80
+
bs.insertBookmark(options.folder,
81
+
PlacesUtils._uri(options.location),
82
+
options.position,
83
+
options.title);
84
+
85
+
if (options.tags.length > 0) {
86
+
PlacesUtils.tagging.tagURI(PlacesUtils._uri(options.location),
87
+
options.tags);
88
+
}
89
+
break;
90
+
case "folder":
91
+
options._itemId =
92
+
PlacesUtils.bookmarks.createFolder(options.folder,
93
+
options.title,
94
+
options.position);
95
+
break;
96
+
case "separator":
97
+
options._itemId =
98
+
PlacesUtils.bookmarks.insertSeparator(options.folder,
99
+
options.position);
100
+
}
101
+
102
+
/*
103
+
if (options.annotations) {
104
+
PlacesUtils.setAnnotationsForItem(options._itemId,
105
+
options.annotations);
106
+
}
107
+
*/
108
+
}
109
+
catch (err) {
110
+
console.exception("Failed to create new bookmark. " + err);
111
+
}
112
+
113
+
if (options.onCreate) {
114
+
safeCallback(undefined, options.onCreate, options);
115
+
}
116
+
};
117
+
118
+
119
+
/**
120
+
* Wrapper for safely calling user-callback functions.
121
+
* TODO: file a bug for getting this into api-utils.
122
+
*/
123
+
function safeCallback(aArgument, aCallbackFunc, aCallbackScope) {
124
+
if (aCallbackFunc) {
125
+
require("timer").setTimeout(function() {
126
+
try {
127
+
if (aCallbackScope)
128
+
aCallbackFunc.call(aCallbackScope, aArgument);
129
+
else
130
+
aCallbackFunc.call(exports, aArgument); // safe "this".
131
+
}
132
+
catch (err) {
133
+
console.exception(err);
134
+
}
135
+
}, 0);
136
+
}
137
+
}
138
+
139
+
140
+
/**
141
+
* This is the basic exposed object for searching.
142
+
* The caller will get access to it via an alias such as "bookmarks"
143
+
* or "history" and call it's .search() method.
144
+
*/
145
+
function PlacesHandler(helperOptions) {
146
+
this.search = function PH_createNewFilter(userOptions) {
147
+
// Merge helper configuration to user configurations.
148
+
let options = validateAndMergeConfigs(userOptions, helperOptions);
149
+
// Create and return a PlacesSearch.
150
+
return new PlacesSearch(options);
151
+
}
152
+
}
153
+
PlacesHandler.prototype = {}
154
+
155
+
156
+
/**
157
+
* apiUtils method does not support "date" type.
158
+
*/
159
+
function checkType(entry, type) {
160
+
switch (type) {
161
+
case "undefined":
162
+
return entry === undefined;
163
+
case "null":
164
+
return entry === null;
165
+
case "date":
166
+
return Object.prototype.toString.call(entry) === "[object Date]";
167
+
case "array":
168
+
return Object.prototype.toString.call(entry) === "[object Array]";
169
+
default:
170
+
return typeof(entry) == type;
171
+
}
172
+
}
173
+
174
+
/**
175
+
* apiUtils method does not support things like "array of optional string" or
176
+
* "array of positive optional number".
177
+
*/
178
+
function checkArrayElementsType(array, type, allowOptionalElement) {
179
+
let arrayIsValid = true;
180
+
array.every(function(elm) {
181
+
if (allowOptionalElement && (elm === undefined || elm === null))
182
+
return true;
183
+
return arrayIsValid = checkType(elm, type);
184
+
});
185
+
return arrayIsValid;
186
+
}
187
+
188
+
/**
189
+
* Take caller-supplied options and merge them with a set of default
190
+
* options.
191
+
*/
192
+
function validateAndMergeConfigs(userOptions, additionalOptions) {
193
+
userOptions = apiUtils.validateOptions(userOptions, {
194
+
phrase: {
195
+
map: function(v) v.toString(),
196
+
is: ["undefined", "string"],
197
+
ok: function(v) !v || v.length > 0,
198
+
msg: "Provided phrase must be a non-empty string."
199
+
},
200
+
host: {
201
+
map: function(v) v.toString(),
202
+
is: ["undefined", "string"],
203
+
ok: function(v) !v || v.length > 0,
204
+
msg: "Provided host must be a non-empty string."
205
+
},
206
+
uri: {
207
+
map: function(v) v.toString(),
208
+
is: ["undefined", "string"],
209
+
ok: function(v) !v || v.length > 0,
210
+
msg: "Provided uri must be a non empty string."
211
+
},
212
+
annotated: {
213
+
is: ["undefined", "array"],
214
+
ok: function (v) !v || v.length > 0,
215
+
msg: "Required annotations must be a valid array of strings."
216
+
},
217
+
bookmarked: apiUtils.validateOptions(userOptions.bookmarked, {
218
+
is: ["undefined", "boolean"],
219
+
ok: function (v) !v || apiUtils.validateOptions(userOptions.bookmarked, {
220
+
tags: {
221
+
is: ["undefined", "array"],
222
+
ok: function(v) !v || (v.length > 0 && checkArrayElementsType(v, "string")),
223
+
msg: "Tags must be a valid array of strings."
224
+
},
225
+
folder: {
226
+
is: ["undefined", "number"],
227
+
ok: function(v) !v || v > 0,
228
+
msg: "Folder id must be a positive number."
229
+
},
230
+
position: {
231
+
is: ["undefined", "number"],
232
+
ok: function(v) !v || v > 0,
233
+
msg: "Position must be a positive number."
234
+
},
235
+
id: {
236
+
is: ["undefined", "number"],
237
+
ok: function(v) !v || v > 0,
238
+
msg: "Bookmark id must be a positive number."
239
+
},
240
+
created: {
241
+
is: ["undefined", "array"],
242
+
ok: function(v) !v || (v.length > 0 && checkArrayElementsType(v, "date", true)),
243
+
msg: "Bookmark creation times must be an array of two optional Date objects."
244
+
},
245
+
modified: {
246
+
is: ["undefined", "array"],
247
+
ok: function(v) !v || (v.length > 0 && checkArrayElementsType(v, "date", true)),
248
+
msg: "Bookmark modification times must be an array of two optional Date objects."
249
+
}
250
+
}),
251
+
msg: "Bookmarked configuration is incorrect."
252
+
}),
253
+
visited: apiUtils.validateOptions(userOptions.visited, {
254
+
is: ["undefined", "object", "boolean"],
255
+
ok: function (v) !v || apiUtils.validateOptions(userOptions.visited, {
256
+
count: {
257
+
is: ["undefined", "array"],
258
+
ok: function(v) !v || (v.length > 0 && checkArrayElementsType(v, "number", true)),
259
+
msg: "Visit count must be an array of two optional numbers."
260
+
},
261
+
transitions: {
262
+
is: ["undefined", "array"],
263
+
ok: function(v) !v || (v.length > 0 && checkArrayElementsType(v, "number", true)),
264
+
msg: "Transitions must be an array of valid transition values."
265
+
},
266
+
when: {
267
+
is: ["undefined", "array"],
268
+
ok: function(v) !v || (v.length > 0 && checkArrayElementsType(v, "date", true)),
269
+
msg: "Visit times must be an array of two optional Date objects."
270
+
},
271
+
includeAllVisits: {
272
+
is: ["undefined", "boolean"]
273
+
}
274
+
}),
275
+
msg: "Visited configuration is incorrect."
276
+
}),
277
+
sortBy: {
278
+
is: ["undefined", "string"],
279
+
ok: function(v) !v || ["none", "title", "time", "uri", "accessCount",
280
+
"lastModified", "frecency"].indexOf(v) != -1,
281
+
msg: "Sorting must define an acceptable string for by."
282
+
},
283
+
sortDir: {
284
+
is: ["undefined", "string"],
285
+
ok: function(v) !v || ["asc", "desc"].indexOf(v) != -1,
286
+
msg: "sorting must define an acceptable direction."
287
+
},
288
+
limit: {
289
+
is: ["undefined", "number"],
290
+
ok: function (v) !v || v > 0,
291
+
msg: "Can limit only on positive number of results."
292
+
},
293
+
onResult: {
294
+
is: ["undefined", "function"]
295
+
},
296
+
onComplete: {
297
+
is: ["undefined", "function"]
298
+
},
299
+
onChange: {
300
+
is: ["undefined", "function"]
301
+
},
302
+
onRemove: {
303
+
is: ["undefined", "function"]
304
+
}
305
+
});
306
+
307
+
// This will only contain visited or bookmarked properties.
308
+
additionalOptions = apiUtils.validateOptions(additionalOptions, {
309
+
visited: {
310
+
is: ["undefined", "object", "boolean"]
311
+
},
312
+
bookmarked: {
313
+
is: ["undefined", "object", "boolean"]
314
+
},
315
+
});
316
+
317
+
// Do the merge.
318
+
for (let prop in additionalOptions) {
319
+
if (!userOptions[prop])
320
+
userOptions[prop] = additionalOptions[prop];
321
+
}
322
+
323
+
return userOptions;
324
+
}
325
+
326
+
327
+
// Defaults for bookmark properties.
328
+
let bookmarkDefaults = {
329
+
title: null,
330
+
type: "bookmark",
331
+
folder: PlacesUtils.unfiledBookmarksFolderId,
332
+
position: PlacesUtils.bookmarks.DEFAULT_INDEX,
333
+
tags: []
334
+
};
335
+
336
+
function validateBookmarkInfo(aOptions, aProvideDefaults) {
337
+
aOptions = apiUtils.validateOptions(aOptions, {
338
+
location: {
339
+
map: function(v) v.toString(),
340
+
is: ["undefined", "string"],
341
+
ok: function(v) !v || v.length > 0,
342
+
msg: "Bookmark location must be a non empty string."
343
+
},
344
+
title: {
345
+
map: function(v) v.toString(),
346
+
is: ["undefined", "string"],
347
+
ok: function(v) !v || v.length > 0
348
+
},
349
+
folder: {
350
+
is: ["undefined", "number"],
351
+
ok: function(v) !v || v > 0,
352
+
msg: "Required containing folder id must be a positive number."
353
+
},
354
+
position: {
355
+
is: ["undefined", "number"],
356
+
ok: function(v) !v || v >= 0,
357
+
msg: "Bookmark position, if present, must be a non-negative number."
358
+
},
359
+
tags: {
360
+
is: ["undefined", "array"],
361
+
ok: function(v) !v || (v.length > 0 && checkArrayElementsType(v, "string")),
362
+
msg: "Tags must be a valid array of strings."
363
+
},
364
+
//annotations: validateAnnotations,
365
+
type: {
366
+
is: ["undefined", "string"],
367
+
ok: function(v) !v || ["bookmark", "separator", "folder"].indexOf(v) != -1,
368
+
msg: "Bookmark type must be one of: bookmark, separator or folder."
369
+
},
370
+
onCreate: {
371
+
is: ["undefined", "function"],
372
+
}
373
+
});
374
+
375
+
if (aProvideDefaults && !aOptions.type) {
376
+
function checkProps(aObject, aDefaultObject) {
377
+
for (let prop in aDefaultObject) {
378
+
if (!(prop in aObject))
379
+
aObject[prop] = aDefaultObject[prop];
380
+
else if (typeof(aObject[prop]) == "object")
381
+
checkProps(aObject[prop], aDefaultObject[prop])
382
+
}
383
+
}
384
+
checkProps(aOptions, bookmarkDefaults);
385
+
386
+
if (aOptions.type == "bookmark" &&
387
+
!("location" in aOptions) || aOptions.title.length == 0)
388
+
throw new Error("Must provide a valid location for the bookmark.");
389
+
390
+
}
391
+
return aOptions;
392
+
}
393
+
394
+
let validateAnnotations = {
395
+
is: ["undefined", "array"],
396
+
ok: function(v) {
397
+
return !v || (v.length > 0 &&
398
+
checkArrayElementsType(v, "object") &&
399
+
v.every(function(a) a.name && a.value))
400
+
},
401
+
msg: "Annotations must be a valid array of { name: '', value: '' } objects."
402
+
};
403
+
404
+
405
+
/**
406
+
* An object that is returned by .search() and can be used to act on
407
+
* entries.
408
+
*/
409
+
function PlacesSearch(aOptions) {
410
+
let query = new PlacesQuery(aOptions);
411
+
412
+
this.change = function PS_change(aChangeOptions) {
413
+
// Allow editing of bookmark properties if a bookmark query.
414
+
if ("bookmarked" in aOptions) {
415
+
validateBookmarkInfo(aChangeOptions);
416
+
}
417
+
else {
418
+
throw new Error("Editing of history is not supported at this time.");
419
+
}
420
+
/*
421
+
// Otherwise only validate annotation properties
422
+
else {
423
+
aChangeOptions = apiUtils.validateOptions(aChangeOptions, {
424
+
annotations: validateAnnotations
425
+
});
426
+
}
427
+
*/
428
+
429
+
// When the owning query has finished, pass results to the walker that
430
+
// will make the changes, re-query to update the results, and then call
431
+
// the user's callback.
432
+
function changeCallback() {
433
+
new QueryExecutor(query, null, aOptions.onChange, aOptions);
434
+
}
435
+
436
+
let walker = new Walker(changeCallback, {}, function(result) {
437
+
let txns = [];
438
+
if ("bookmarked" in aOptions) {
439
+
let bs = PlacesUtils.bookmarks;
440
+
// location
441
+
if (aChangeOptions.location)
442
+
txns.push(new PlacesEditBookmarkURITransaction(result._itemId,
443
+
PlacesUtils._uri(aChangeOptions.location)));
444
+
// title
445
+
if (aChangeOptions.title) {
446
+
txns.push(new PlacesEditItemTitleTransaction(result._itemId, aChangeOptions.title));
447
+
}
448
+
// folder & position
449
+
if (aChangeOptions.folder != undefined || aChangeOptions.position != undefined) {
450
+
let position = (aChangeOptions.position === undefined) ? -1 : aChangeOptions.position;
451
+
txns.push(new PlacesMoveItemTransaction(result._itemId,
452
+
aChangeOptions.folder || result.folder,
453
+
position));
454
+
}
455
+
// tags
456
+
if (aChangeOptions.tags) {
457
+
let uri = PlacesUtils._uri(aChangeOptions.location || result.location);
458
+
txns.push(new PlacesTagURITransaction(uri, aChangeOptions.tags));
459
+
}
460
+
/*
461
+
// annotations
462
+
if (aChangeOptions.annotations) {
463
+
aChangeOptions.annotations.forEach(function(anno) {
464
+
txns.push(new PlacesSetItemAnnotationTransaction(result._itemId, anno));
465
+
});
466
+
}
467
+
*/
468
+
}
469
+
else if (aChangeOptions.annotations) {
470
+
aChangeOptions.annotations.forEach(function(anno) {
471
+
txns.push(new PlacesSetPageAnnotationTransaction(result.location, anno));
472
+
});
473
+
}
474
+
475
+
(new PlacesAggregatedTransaction("Changing " + result.title, txns)).doTransaction();
476
+
});
477
+
new QueryExecutor(query, null, walker.run, walker);
478
+
};
479
+
480
+
this.remove = function PS_remove() {
481
+
if (!("bookmarked" in aOptions)) {
482
+
throw new Error("Removal of history is not supported at this time.");
483
+
}
484
+
485
+
// When the owning query has finished, pass results to the walker that
486
+
// will make the changes, re-query to update the results, and then call
487
+
// the user's callback.
488
+
function removeCallback() {
489
+
new QueryExecutor(query, null, aOptions.onRemove, aOptions);
490
+
}
491
+
492
+
// When the owning query has finished, pass results to the walker that
493
+
// will remove them from the database.
494
+
let walker = new Walker(removeCallback, aOptions, function(result) {
495
+
(new PlacesRemoveItemTransaction(result._itemId)).doTransaction();
496
+
});
497
+
new QueryExecutor(query, null, walker.run, walker);
498
+
};
499
+
500
+
if (aOptions.onResult || aOptions.onComplete)
501
+
new QueryExecutor(query, aOptions.onResult, aOptions.onComplete, aOptions);
502
+
}
503
+
PlacesSearch.prototype = {}
504
+
505
+
506
+
/**
507
+
* Executes a query and receives results from it.
508
+
*/
509
+
function QueryExecutor(aPlacesQuery, aOnResult, aOnComplete, aScope) {
510
+
this.onResult = aOnResult;
511
+
this.onComplete = aOnComplete;
512
+
this.scope = aScope;
513
+
this.results = [];
514
+
515
+
aPlacesQuery.execute(this.resultsCallback, this);
516
+
}
517
+
518
+
QueryExecutor.prototype = {
519
+
resultsCallback: function QX_resultsCallback(aResult) {
520
+
// Query has finished returning results.
521
+
if (!aResult && this.onComplete) {
522
+
this.scope.results = this.results;
523
+
safeCallback(null, this.onComplete, this.scope);
524
+
}
525
+
526
+
// There are results but we don't want to notify caller before completion.
527
+
else if (this.onComplete)
528
+
this.results.push(new Place(aResult));
529
+
530
+
// Send result to the caller.
531
+
if (this.onResult)
532
+
safeCallback(new Place(aResult), this.onResult, this.scope);
533
+
}
534
+
}
535
+
536
+
537
+
/**
538
+
* Walks through all results from an owning query that are passed to run,
539
+
* then calls aUserCallback in the scope of aUserScope. It will also set
540
+
* the results of the owning query as aUserScope.results. This ensures that
541
+
* when query results have their change/remove methods called, the result set
542
+
* is updated to reflect those calls.
543
+
*/
544
+
function Walker(aUserCallback, aUserScope, aMapFunction) {
545
+
this.userCallback = aUserCallback;
546
+
this.userScope = aUserScope;
547
+
this.mapFunction = aMapFunction;
548
+
}
549
+
550
+
Walker.prototype = {
551
+
run: function WLKR_run() {
552
+
// Process results.
553
+
this.results.forEach(this.mapFunction);
554
+
if (this.userScope)
555
+
this.userScope.results = this.results;
556
+
if (this.userCallback)
557
+
safeCallback(null, this.userCallback, this.userScope || undefined);
558
+
}
559
+
}
560
+
561
+
562
+
/**
563
+
* Place object, representing a single result in a set of search results.
564
+
*/
565
+
function Place(aOptions) {
566
+
for (var i in aOptions) {
567
+
switch (i) {
568
+
// Omitted for now.
569
+
case "pageId": // id from moz_places table, used for sql queries
570
+
case "referringVisitId":
571
+
case "revHost":
572
+
case "sessionId":
573
+
case "transitionType":
574
+
case "type": // type const from nsINavBookmarksService
575
+
case "visitId":
576
+
continue;
577
+
break;
578
+
// Rename bookmarkIndex to position.
579
+
case "bookmarkIndex":
580
+
this.position = aOptions[i];
581
+
break;
582
+
// Id from moz_bookmarks table, used for the internal boomark apis.
583
+
// HACK: Expose as "private" because we need to access it for
584
+
// internal use such as deletion, and query folders.
585
+
case "itemId":
586
+
this._itemId = aOptions[i];
587
+
break;
588
+
// Rename parentId to folder.
589
+
case "parentId":
590
+
this.folder = aOptions[i];
591
+
// Rename readableType to bookmarkType.
592
+
case "readableType":
593
+
this.type = aOptions[i] == "container" ? "folder" : aOptions[i];
594
+
break;
595
+
// Rename referringUri to referrer.
596
+
case "referringUri":
597
+
this.referrer = aOptions[i];
598
+
break;
599
+
// Rename uri to location.
600
+
case "uri":
601
+
this.location = aOptions[i];
602
+
break;
603
+
// Name/value does not need to change.
604
+
case "accessCount":
605
+
case "dateAdded":
606
+
case "frecency":
607
+
case "host":
608
+
case "icon": // is a URL, should rename to iconURL?
609
+
case "isBookmarked":
610
+
case "lastModified":
611
+
case "tags":
612
+
case "title":
613
+
case "time":
614
+
this[i] = aOptions[i];
615
+
break;
616
+
}
617
+
}
618
+
}
619
+
620
+
/******************************************************************************
621
+
* THE CODE FROM HERE TO THE END OF THE FILE IS THE JETPACK-LESS PLACES QUERY
622
+
* MODULE. IT MUST REMAIN JETPACK-FREE. ANY MODIFICATIONS MUST BE FILED AS
623
+
* BUGS AND MARKED AS BLOCKING BUG 522572.
624
+
*****************************************************************************/
625
+
626
+
/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
627
+
* vim: sw=2 ts=2 sts=2 expandtab
628
+
* ***** BEGIN LICENSE BLOCK *****
629
+
* Version: MPL 1.1/GPL 2.0/LGPL 2.1
630
+
*
631
+
* The contents of this file are subject to the Mozilla Public License Version
632
+
* 1.1 (the "License"); you may not use this file except in compliance with
633
+
* the License. You may obtain a copy of the License at
634
+
* http://www.mozilla.org/MPL/
635
+
*
636
+
* Software distributed under the License is distributed on an "AS IS" basis,
637
+
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
638
+
* for the specific language governing rights and limitations under the
639
+
* License.
640
+
*
641
+
* The Original Code is mozilla.org code.
642
+
*
643
+
* The Initial Developer of the Original Code is
644
+
* Mozilla Corporation.
645
+
* Portions created by the Initial Developer are Copyright (C) 2010
646
+
* the Initial Developer. All Rights Reserved.
647
+
*
648
+
* Contributor(s):
649
+
* Marco Bonardo <mak77@bonardo.net> (original author)
650
+
* David Dahl <ddahl@mozilla.com>
651
+
* Dietrich Ayala <dietrich@mozilla.com>
652
+
*
653
+
* Alternatively, the contents of this file may be used under the terms of
654
+
* either the GNU General Public License Version 2 or later (the "GPL"), or
655
+
* the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
656
+
* in which case the provisions of the GPL or the LGPL are applicable instead
657
+
* of those above. If you wish to allow use of your version of this file only
658
+
* under the terms of either the GPL or the LGPL, and not to allow others to
659
+
* use your version of this file under the terms of the MPL, indicate your
660
+
* decision by deleting the provisions above and replace them with the notice
661
+
* and other provisions required by the GPL or the LGPL. If you do not delete
662
+
* the provisions above, a recipient may use your version of this file under
663
+
* the terms of any one of the MPL, the GPL or the LGPL.
664
+
*
665
+
* ***** END LICENSE BLOCK ***** */
666
+
667
+
//const EXPORTED_SYMBOLS = ["PlacesQuery"];
668
+
669
+
/* This is a pure async querying API.
670
+
* It provides non-liveupdating query results passed to a callback function.
671
+
*
672
+
* NOTE: history results returned by this object may be up to two minutes behind
673
+
* since it does not handle TEMP tables. We plan to remove them, so this bad
674
+
* behavior will be rectified at that point.
675
+
*
676
+
* TODO:
677
+
* - Hierarchal queries.
678
+
* - Accept a place: uri as input.
679
+
* - Par querying capabilities with the old querying API.
680
+
* - Faster queries.
681
+
* - Create a PlacesLiveQuery wrapper that will query through an internal
682
+
* PlacesQuery object and then will maintain an updated copy of the results.
683
+
* - Use PlacesLiveQuery wrapper in our views.
684
+
* - Add further querying capabilities.
685
+
*
686
+
* EXAMPLE:
687
+
*
688
+
* let query = new PlacesQuery({_QueryConf_});
689
+
*
690
+
* query.execute(function(result) {
691
+
* if (result)
692
+
* dump("Got a result: " + [result.title, result.uri, result.readableType].join(", "));
693
+
* else
694
+
* dump("Finished executing query!\n");
695
+
* }, this);
696
+
*
697
+
*
698
+
* _QueryConf_ = {
699
+
* phrase: string.
700
+
* Containing this string in either title, uri or tags. Case
701
+
* insensitive. Can use ^ and $ to match at beginning or end.
702
+
* host: string.
703
+
* Containing this string in the host. Case insensitive.
704
+
* Can use ^ and $ to match at beginning or end.
705
+
* uri: string.
706
+
* Containing this string in the uri. Case insensitive.
707
+
* Can use ^ and $ to match beginning or end.
708
+
* annotated: array of strings.
709
+
* With these annotations (Either page or item).
710
+
* bookmarked: object
711
+
* {
712
+
* tags: array of strings.
713
+
* Tagged with these tags.
714
+
* folder: number.
715
+
* Inside this folder. (non-recursive)
716
+
* position: number.
717
+
* At this position. (relative to folder).
718
+
* If undefined or null matches all children.
719
+
* If no folder is defined, position is ignored.
720
+
* id: number.
721
+
* Bookmarked with this id.
722
+
* createdBegin: optional Date object
723
+
* Bookmarks created after this time (included).
724
+
* Defaults to epoch.
725
+
* createdEnd: optional Date object
726
+
* Bookmarks created before this time (included).
727
+
* Defaults to now.
728
+
* modifiedBegin: optional Date object
729
+
* Bookmarks modified after this time (included).
730
+
* Defaults to epoch.
731
+
* modifiedEnd: optional Date object
732
+
* Bookmarks modified before this time (included).
733
+
* Defaults to now.
734
+
* onlyContainers: boolean.
735
+
* Removes any non-container from results.
736
+
* Default is false.
737
+
* excludeReadOnlyContainers: boolean.
738
+
* Removes read only containers from results.
739
+
* Default is false.
740
+
* }
741
+
* visited: object
742
+
* {
743
+
* countMin: optional number.
744
+
* With more than this many visits.
745
+
* Defaults to 0.
746
+
* This is lazily based on visit_count, thus is not going to work
747
+
* for not counted transitions: embed, download, framed_link.
748
+
* countMax: optional number.
749
+
* With less than this many visits.
750
+
* Defaults to inf.
751
+
* This is lazily based on visit_count, thus is not going to work
752
+
* for not counted transitions: embed, download, framed_link.
753
+
* transitions: array of transition types.
754
+
* With at least one visit for each of these transitions.
755
+
* begin: optional Date object
756
+
* With visits after this time (included).
757
+
* Defaults to epoch.
758
+
* end: optional Date object
759
+
* With visits before this time (included).
760
+
* Defaults to now.
761
+
* excludeRedirectSources: boolean.
762
+
* Removes redirects sources from results.
763
+
* Default is false.
764
+
* excludeRedirectTargets: boolean.
765
+
* Removes redirects targets from results.
766
+
* Default is false.
767
+
* includeHidden: boolean.
768
+
* Includes also pages marked as hidden.
769
+
* Default is false.
770
+
* includeAllVisits: boolean.
771
+
* Returns all visits ungrouped.
772
+
* Default is false, that means visits are grouped by uri.
773
+
* }
774
+
* sortBy: string.
775
+
* Either "none", "title", "time", "uri", "accessCount", "lastModified",
776
+
* "frecency". Defaults to "none".
777
+
* sortDir: string.
778
+
* Either "asc" or "desc". Defaults to "asc".
779
+
* group: string.
780
+
* Either "tags", "containers", "days", "months", "years" or "domains".
781
+
* Defaults to "none".
782
+
* NOTE: Not yet implemented.
783
+
* limit: number.
784
+
* Maximum number of results to return. Defaults to all results.
785
+
* merge: string.
786
+
* How to merge this query's results with others in the same request.
787
+
* Valid values:
788
+
* - "union": merge results from the 2 queries.
789
+
* - "except": exclude current results from the previous ones.
790
+
* - "intersect": only current results that are also in previous ones.
791
+
* }
792
+
*
793
+
*/
794
+
795
+
////////////////////////////////////////////////////////////////////////////////
796
+
//// Constants and Getters
797
+
798
+
//const Cc = Components.classes;
799
+
//const Ci = Components.interfaces;
800
+
//const Cr = Components.results;
801
+
//const Cu = Components.utils;
802
+
803
+
const TAGS_SEPARATOR = ", ";
804
+
805
+
const TAGS_SQL_FRAGMENT =
806
+
"("
807
+
+ "SELECT GROUP_CONCAT(tag_title, ', ') "
808
+
+ "FROM ( "
809
+
+ "SELECT t_t.title AS tag_title "
810
+
+ "FROM moz_bookmarks b_t "
811
+
+ "JOIN moz_bookmarks t_t ON t_t.id = b_t.parent "
812
+
+ "WHERE b_t.fk = h.id "
813
+
+ "AND LENGTH(t_t.title) > 0 "
814
+
+ "AND t_t.parent = :tags_folder "
815
+
+ "ORDER BY t_t.title COLLATE NOCASE ASC "
816
+
+ ") WHERE b.id NOTNULL "
817
+
+ ")";
818
+
819
+
const REFERRING_URI_SQL_FRAGMENT =
820
+
"("
821
+
+ "SELECT refh.url FROM moz_places refh "
822
+
+ "JOIN moz_historyvisits refv ON refh.id = refv.place_id "
823
+
+ "WHERE refv.id = v.from_visit "
824
+
+ ")";
825
+
826
+
Cu.import("resource://gre/modules/XPCOMUtils.jsm", this);
827
+
Cu.import("resource://gre/modules/Services.jsm", this);
828
+
Cu.import("resource://gre/modules/PlacesUtils.jsm", this);
829
+
830
+
XPCOMUtils.defineLazyGetter(this, "DB", function() {
831
+
return PlacesUtils.history.QueryInterface(Ci.nsPIPlacesDatabase)
832
+
.DBConnection;
833
+
});
834
+
835
+
836
+
////////////////////////////////////////////////////////////////////////////////
837
+
//// Utils and Helpers
838
+
839
+
function checkType(entry, type) {
840
+
switch (type) {
841
+
case "undefined":
842
+
return entry === undefined;
843
+
case "null":
844
+
return entry === null;
845
+
case "date":
846
+
return Object.prototype.toString.call(entry) === "[object Date]";
847
+
case "array":
848
+
// TODO: Use ES5 isArray() once available.
849
+
// NOTE: current method fails if the array comes from JSON.parse.
850
+
return Object.prototype.toString.call(entry) === "[object Array]";
851
+
default:
852
+
if (entry === null) // typeof(null) == "object" but we have a "null" type.
853
+
return false;
854
+
return typeof(entry) == type;
855
+
}
856
+
}
857
+
858
+
859
+
function checkArrayElementsType(array, type, allowOptionalElement) {
860
+
let arrayIsValid = true;
861
+
array.every(function(elm) {
862
+
if (allowOptionalElement && (elm === undefined || elm === null))
863
+
return true;
864
+
return arrayIsValid = checkType(elm, type);
865
+
});
866
+
return arrayIsValid;
867
+
}
868
+
869
+
870
+
function isValidArray(aObj, aValidator)
871
+
{
872
+
let validArray = checkType(aObj, "array");
873
+
if (validArray && aValidator) {
874
+
if (!checkType(aValidator, "function"))
875
+
throw new Error("Array validator must be a function.");
876
+
return aValidator(aObj);
877
+
}
878
+
return validArray;
879
+
}
880
+
881
+
882
+
function getReadableItemType(aResultItem, aItemType)
883
+
{
884
+
if (aItemType) {
885
+
// it's a bookmark.
886
+
if (!aResultItem.uri || aResultItem.uri.substr(0, 6) == "place:") {
887
+
switch (aItemType) {
888
+
case Ci.nsINavBookmarksService.TYPE_SEPARATOR:
889
+
return "separator";
890
+
default:
891
+
return "container";
892
+
}
893
+
}
894
+
return "bookmark";
895
+
}
896
+
if (aResultItem.visitId)
897
+
return "visit";
898
+
return "page";
899
+
}
900
+
901
+
902
+
function getNodeType(aResultItem, aItemType) {
903
+
if (aResultItem.transitionType)
904
+
return Ci.nsINavHistoryResultNode.RESULT_TYPE_FULL_VISIT;
905
+
906
+
let isQuery = aResultItem.uri && aResultItem.uri.substr(0, 6) == "place:";
907
+
if (aResultItem.isBookmarked) {
908
+
if (aItemType == PlacesUtils.bookmarks.TYPE_FOLDER)
909
+
return Ci.nsINavHistoryResultNode.RESULT_TYPE_FOLDER;
910
+
if (aItemType == PlacesUtils.bookmarks.TYPE_SEPARATOR)
911
+
return Ci.nsINavHistoryResultNode.RESULT_TYPE_SEPARATOR;
912
+
913
+
if (isQuery && /^place:folder=[^&]+$/i.test(aResultItem.uri))
914
+
return Ci.nsINavHistoryResultNode.RESULT_TYPE_FOLDER_SHORTCUT;
915
+
}
916
+
917
+
return isQuery ? Ci.nsINavHistoryResultNode.RESULT_TYPE_QUERY
918
+
: Ci.nsINavHistoryResultNode.RESULT_TYPE_URI;
919
+
}
920
+
921
+
922
+
function TextMatch(aText)
923
+
{
924
+
if (aText.substr(0, 1) == "^")
925
+
this.matchBegin = true;
926
+
if (aText.substr(-1, 1) == "$")
927
+
this.matchEnd = true;
928
+
this.exactMatch = this.matchEnd && this.matchBegin;
929
+
let cutFrom = this.matchBegin ? 1 : 0;
930
+
let cutLen = aText.length - cutFrom - (this.matchEnd ? 1 : 0);
931
+
this.value = aText.substr(cutFrom, cutLen);
932
+
}
933
+
934
+
TextMatch.prototype = {
935
+
matchBegin: false,
936
+
matchEnd: false,
937
+
exactMatch: false,
938
+
value: "",
939
+
940
+
getStringForLike: function TM_getStringForLike(aStmt) {
941
+
let escValue = aStmt.escapeStringForLIKE(this.value, '/');
942
+
if (this.exactMatch)
943
+
return escValue;
944
+
if (this.matchBegin)
945
+
return escValue + "%";
946
+
if (this.matchEnd)
947
+
return "%" + escValue;
948
+
return "%" + escValue + "%";
949
+
},
950
+
951
+
getRegExp: function TM_getRegExp(aUseWordBoundaries) {
952
+
let beginMod = aUseWordBoundaries ? "\\b" : "^";
953
+
let endMod = aUseWordBoundaries ? "\\b" : "$";
954
+
if (this.exactMatch)
955
+
return new RegExp(beginMod + this.value + endMod, "i");
956
+
if (this.matchBegin)
957
+
return new RegExp(beginMod + this.value, "i");
958
+
if (this.matchEnd)
959
+
return new RegExp(this.value + endMod, "i");
960
+
return new RegExp(this.value, "i");
961
+
}
962
+
}
963
+
964
+
965
+
////////////////////////////////////////////////////////////////////////////////
966
+
//// (De)Serializers
967
+
968
+
const SPECIAL_FOLDERS = {
969
+
BOOKMARKS_MENU_FOLDER: PlacesUtils.bookmarksMenuFolderId
970
+
, TAGS_FOLDER: PlacesUtils.tagsFolderId
971
+
, UNFILED_BOOKMARKS_FOLDER: PlacesUtils.unfiledBookmarksFolderId
972
+
, TOOLBAR_FOLDER: PlacesUtils.toolbarFolderId
973
+
};
974
+
975
+
const TIME_REFERENCE = {
976
+
0: 0 // EPOCH
977
+
, 1: new Date().setHours(0,0,0,0) * 1000 // TODAY'S START
978
+
, 2: Date.now() * 1000 // NOW
979
+
};
980
+
981
+
function deserializeLegacyPlaceUrl(aUrl) {
982
+
let queryConfs = [];
983
+
// Strip "place:" scheme.
984
+
aUrl = aUrl.substr(7);
985
+
// Split multiple queries.
986
+
let queries = aQuery.split("OR");
987
+
// Put each param in an array of objects like { name:, value: }.
988
+
let re = new RegExp("([^?=&]+)(=([^&]*))?", "gi");
989
+
queries.forEach(function(aQuery) {
990
+
let params = {};
991
+
let match = null;
992
+
while ((match = re.exec(aQuery))) {
993
+
let name = match[1].toLowerCase();
994
+
let value = match[3];
995
+
// Same key can have multiple params, for simplicity make values arrays.
996
+
if (!(name in params))
997
+
params[name] = [];
998
+
params[name].push(value);
999
+
};
1000
+
1001
+
let conf = {}
1002
+
for (let name in params) {
1003
+
switch(name) {
1004
+
case "begintime":
1005
+
if (!("visited" in conf))
1006
+
conf.visited = {}
1007
+
let begintimeref = 0;
1008
+
if ("begintimeref" in params)
1009
+
begintimeref += params["begintimeref"];
1010
+
conf.visited.begin = new Date((timeref + params["begintime"][0])/1000);
1011
+
break;
1012
+
case "endtime":
1013
+
if (!("visited" in conf))
1014
+
conf.visited = {}
1015
+
let endtimeref = 0;
1016
+
if ("endtimeref" in params)
1017
+
endtimeref += params["endtimeref"];
1018
+
conf.visited.end = new Date((timeref + params["endtime"][0])/1000);
1019
+
break;
1020
+
case "terms":
1021
+
conf.phrase = params["terms"][0];
1022
+
break;
1023
+
case "minvisits":
1024
+
if (!("visited" in conf))
1025
+
conf.visited = {}
1026
+
conf.visited.countMin = params["minvisits"][0];
1027
+
break;
1028
+
case "maxvisits":
1029
+
if (!("visited" in conf))
1030
+
conf.visited = {}
1031
+
conf.visited.countMax = params["maxvisits"][0];
1032
+
break;
1033
+
case "onlybookmarked":
1034
+
if (!("bookmarked" in conf))
1035
+
conf.bookmarked = {};
1036
+
break;
1037
+
case "domain":
1038
+
if ("domainishost" in params) {
1039
+
if (params["domainishost"] == 1)
1040
+
conf.host = "^" + params["domain"][0] + "$";
1041
+
}
1042
+
else
1043
+
conf.host = params["domain"][0];
1044
+
break;
1045
+
case "folder":
1046
+
if (!("bookmarked" in conf))
1047
+
conf.bookmarked = {};
1048
+
if (params["folder"].length == 1) {
1049
+
let folderId;
1050
+
if (/[a-z]/.test(folderId)) {
1051
+
if (folderId in SPECIAL_FOLDERS)
1052
+
folderId = SPECIAL_FOLDERS[folderId];
1053
+
}
1054
+
else {
1055
+
folderId = params["folder"][0];
1056
+
}
1057
+
if (folderId)
1058
+
conf.bookmarked.folder = folderId;
1059
+
}
1060
+
// TODO: due to a nice API confusion, if there is more than one folder
1061
+
// they are wrongly ORed.
1062
+
break;
1063
+
case "annotation":
1064
+
if ("!annotation" in params) {
1065
+
// TODO: handle !annotation=1, should split an except query.
1066
+
}
1067
+
else {
1068
+
conf.annotated = params["annotation"];
1069
+
}
1070
+
break;
1071
+
case "uri":
1072
+
if ("uriisprefix" in params) {
1073
+
if (params["uriisprefix"] == 1)
1074
+
conf.host = "^" + params["uri"][0];
1075
+
}
1076
+
else
1077
+
conf.uri = "^" + params["domain"][0] + "$";
1078
+
break;
1079
+
case "group":
1080
+
// Sadly this has been killed lot of time ago for result type.
1081
+
break;
1082
+
case "sort":
1083
+
let opts = Ci.nsINavHistoryQueryOptions;
1084
+
switch(params["sort"][0]) {
1085
+
case opts.SORT_BY_TITLE_ASCENDING:
1086
+
conf.sortBy = "title";
1087
+
conf.sortDir = "ASC";
1088
+
break;
1089
+
case opts.SORT_BY_TITLE_DESCENDING:
1090
+
conf.sortBy = "title";
1091
+
conf.sortDir = "DESC";
1092
+
break;
1093
+
case opts.SORT_BY_DATE_ASCENDING:
1094
+
conf.sortBy = "time";
1095
+
conf.sortDir = "ASC";
1096
+
break;
1097
+
case opts.SORT_BY_DATE_DESCENDING:
1098
+
conf.sortBy = "time";
1099
+
conf.sortDir = "DESC";
1100
+
break;
1101
+
case opts.SORT_BY_URI_ASCENDING:
1102
+
conf.sortBy = "uri";
1103
+
conf.sortDir = "ASC";
1104
+
break;
1105
+
case opts.SORT_BY_URI_DESCENDING:
1106
+
conf.sortBy = "uri";
1107
+
conf.sortDir = "DESC";
1108
+
break;
1109
+
case opts.SORT_BY_VISITCOUNT_ASCENDING:
1110
+
conf.sortBy = "accessCount";
1111
+
conf.sortDir = "ASC";
1112
+
break;
1113
+
case opts.SORT_BY_VISITCOUNT_DESCENDING:
1114
+
conf.sortBy = "accessCount";
1115
+
conf.sortDir = "DESC";
1116
+
break;
1117
+
case opts.SORT_BY_DATEADDED_ASCENDING:
1118
+
conf.sortBy = "dateAdded";
1119
+
conf.sortDir = "ASC";
1120
+
break;
1121
+
case opts.SORT_BY_DATEADDED_DESCENDING:
1122
+
conf.sortBy = "dateAdded";
1123
+
conf.sortDir = "DESC";
1124
+
break;
1125
+
case opts.SORT_BY_LASTMODIFIED_ASCENDING:
1126
+
conf.sortBy = "lastModified";
1127
+
conf.sortDir = "ASC";
1128
+
break;
1129
+
case opts.SORT_BY_LASTMODIFIED_DESCENDING:
1130
+
conf.sortBy = "lastModified";
1131
+
conf.sortDir = "DESC";
1132
+
break;
1133
+
case opts.SORT_BY_NONE:
1134
+
// default.
1135
+
break;
1136
+
case opts.SORT_BY_KEYWORD_ASCENDING:
1137
+
case opts.SORT_BY_KEYWORD_DESCENDING:
1138
+
case opts.SORT_BY_TAGS_ASCENDING:
1139
+
case opts.SORT_BY_TAGS_DESCENDING:
1140
+
case opts.SORT_BY_ANNOTATION_ASCENDING:
1141
+
case opts.SORT_BY_ANNOTATION_DESCENDING:
1142
+
// Not supported.
1143
+
break;
1144
+
};
1145
+
break;
1146
+
case "type":
1147
+
switch (params["type"][0]) {
1148
+
case Ci.nsINavHistoryQueryOptions.RESULTS_AS_VISIT:
1149
+
case Ci.nsINavHistoryQueryOptions.RESULTS_AS_FULL_VISIT:
1150
+
if (!("visited" in conf))
1151
+
conf.visited = {};
1152
+
conf.visited.includeAllVisits = true;
1153
+
break;
1154
+
case Ci.nsINavHistoryQueryOptions.RESULTS_AS_DATE_QUERY:
1155
+
case Ci.nsINavHistoryQueryOptions.RESULTS_AS_SITE_QUERY:
1156
+
case Ci.nsINavHistoryQueryOptions.RESULTS_AS_DATE_SITE_QUERY:
1157
+
// TODO, need to define how to make date grouping.
1158
+
break;
1159
+
case Ci.nsINavHistoryQueryOptions.RESULTS_AS_TAG_QUERY:
1160
+
case Ci.nsINavHistoryQueryOptions.RESULTS_AS_TAG_CONTENTS:
1161
+
conf.group = "tags";
1162
+
break;
1163
+
}
1164
+
break;
1165
+
case "excludeitems":
1166
+
if (!("bookmarked" in conf))
1167
+
conf.bookmarked = {};
1168
+
if (params["excludeitems"][0] == 1)
1169
+
conf.bookmarked.onlyContainers = true;
1170
+
break;
1171
+
case "excludequeries":
1172
+
if (!("bookmarked" in conf))
1173
+
conf.bookmarked = {};
1174
+
break;
1175
+
case "excludereadonlyfolders":
1176
+
if (!("bookmarked" in conf))
1177
+
conf.bookmarked = {};
1178
+
if (params["excludereadonlyfolders"][0] == 1)
1179
+
conf.bookmarked.excludeReadOnlyContainers = true;
1180
+
break;
1181
+
case "excludeitemifparenthasannotation":
1182
+
// Not supported, we should remove livemarks children from bookmarks
1183
+
// instead.
1184
+
break;
1185
+
case "expandqueries":
1186
+
// Not supported, the query should have onlyContainers instead.
1187
+
break;
1188
+
case "originaltitle":
1189
+
// Never been implemented, and it is not yet.
1190
+
break;
1191
+
case "includehidden":
1192
+
if (!("visited" in conf))
1193
+
conf.visited = {};
1194
+
if (params["includehidden"][0] == 1)
1195
+
conf.visited.includeHidden = true;
1196
+
break;
1197
+
case "redirectsmode":
1198
+
if (!("visited" in conf))
1199
+
conf.visited = {};
1200
+
switch(params["redirectsMode"][0]) {
1201
+
case Ci.nsINavHistoryQueryOptions.REDIRECTS_MODE_TARGET:
1202
+
conf.visited.excludeRedirectSources = true;
1203
+
break;
1204
+
case Ci.nsINavHistoryQueryOptions.REDIRECTS_MODE_SOURCE:
1205
+
conf.visited.excludeRedirectTargets = true;
1206
+
break;
1207
+
}
1208
+
break;
1209
+
case "maxresults":
1210
+
conf.limit = params["maxresults"][0];
1211
+
break;
1212
+
case "querytype":
1213
+
if (params["querytype"][0] == Ci.nsINavHistoryQueryOptions.QUERY_TYPE_BOOKMARKS &&
1214
+
!("bookmarked" in conf))
1215
+
conf.bookmarked = {};
1216
+
break;
1217
+
case "tag":
1218
+
if ("!tags" in params) {
1219
+
// TODO: handle !annotation=1, should split out an except query.
1220
+
}
1221
+
else {
1222
+
if (!("bookmarked" in conf))
1223
+
conf.bookmarked = {};
1224
+
conf.bookmarked.tags = params["tag"];
1225
+
}
1226
+
break;
1227
+
case "asyncenabled":
1228
+
// Ignored, this is always async.
1229
+
break;
1230
+
}
1231
+
}
1232
+
1233
+
// Folder shortcuts.
1234
+
if (/place:folder=[^&]/.test(aUrl))
1235
+
conf.group = "containers";
1236
+
1237
+
queryConfs.push(conf);
1238
+
});
1239
+
return queryConfs;
1240
+
}
1241
+
1242
+
1243
+
////////////////////////////////////////////////////////////////////////////////
1244
+
//// QueryConf
1245
+
1246
+
function QueryConf(aQueryConf)
1247
+
{
1248
+
// Safe initialize: use default values if inputs are invalid.
1249
+
for (let prop in aQueryConf) {
1250
+
this[prop] = aQueryConf[prop];
1251
+
}
1252
+
}
1253
+
1254
+
QueryConf.prototype = {
1255
+
_phrase: new TextMatch(""),
1256
+
get phrase() this._phrase.value,
1257
+
set phrase(aVal)
1258
+
{
1259
+
if (checkType(aVal, "string"))
1260
+
this._phrase = new TextMatch(aVal);
1261
+
return this._phrase.value;
1262
+
},
1263
+
1264
+
_host: new TextMatch(""),
1265
+
get host() this._host.value,
1266
+
set host(aVal)
1267
+
{
1268
+
if (checkType(aVal, "string"))
1269
+
this._host = new TextMatch(aVal);
1270
+
return this._host.value;
1271
+
},
1272
+
1273
+
_uri: new TextMatch(""),
1274
+
get uri() this._uri.value,
1275
+
set uri(aVal)
1276
+
{
1277
+
if (checkType(aVal, "string"))
1278
+
this._uri = new TextMatch(aVal);
1279
+
return this._uri.value;
1280
+
},
1281
+
1282
+
_annotated: [],
1283
+
get annotated() this._annotated,
1284
+
set annotated(aVal)
1285
+
{
1286
+
if (isValidArray(aVal, function(v) v.length > 0 && checkArrayElementsType(v, "string")))
1287
+
this._annotated = aVal;
1288
+
return this._annotated;
1289
+
},
1290
+
1291
+
_bookmarked: null,
1292
+
get bookmarked() this._bookmarked,
1293
+
set bookmarked(aVal)
1294
+
{
1295
+
if (checkType(aVal, "object")) {
1296
+
let options = { tags: []
1297
+
, folder: null
1298
+
, position: null
1299
+
, id: null
1300
+
, createdBegin: null
1301
+
, createdEnd: null
1302
+
, modifiedBegin: null
1303
+
, modifiedEnd: null
1304
+
, onlyContainers: false
1305
+
, excludeReadOnlyContainers: false
1306
+
};
1307
+
1308
+
if ("tags" in aVal &&
1309
+
isValidArray(aVal.tags, function(v) v.length > 0 && checkArrayElementsType(v, "string")))
1310
+
options.tags = aVal.tags;
1311
+
1312
+
if ("folder" in aVal && aVal.folder > 0)
1313
+
options.folder = aVal.folder;
1314
+
1315
+
if ("position" in aVal && aVal.position >= 0)
1316
+
options.position = aVal.position;
1317
+
1318
+
if ("id" in aVal && checkType(aVal.id, "number"))
1319
+
options.id = aVal.id;
1320
+
1321
+
if ("createdBegin" in aVal && checkType(aVal.createdBegin, "date"))
1322
+
options.createdBegin = aVal.createdBegin;
1323
+
1324
+
if ("createdEnd" in aVal && checkType(aVal.createdEnd, "date"))
1325
+
options.createdEnd = aVal.createdEnd;
1326
+
1327
+
if ("modifiedBegin" in aVal && checkType(aVal.modifiedBegin, "date"))
1328
+
modifiedBegin = aVal.modifiedBegin;
1329
+
if ("end" in aVal && checkType(aVal.modifiedEnd, "date"))
1330
+
modifiedEnd = aVal.modifiedEnd;
1331
+
1332
+
if ("onlyContainers" in aVal &&
1333
+
checkType(aVal.onlyContainers, "boolean"))
1334
+
options.onlyContainers = aVal.onlyContainers;
1335
+
1336
+
if ("excludeReadOnlyContainers" in aVal &&
1337
+
checkType(aVal.excludeReadOnlyContainers, "boolean"))
1338
+
options.excludeReadOnlyContainers = aVal.excludeReadOnlyContainers;
1339
+
1340
+
this._bookmarked = options;
1341
+
}
1342
+
// Set simple bool for isBookmarked with no other parameters.
1343
+
else if(aVal) {
1344
+
this._bookmarked = true;
1345
+
}
1346
+
return this._bookmarked;
1347
+
},
1348
+
1349
+
_visited: null,
1350
+
get visited() this._visited,
1351
+
set visited(aVal)
1352
+
{
1353
+
if (checkType(aVal, "object")) {
1354
+
let options = { countMin: null
1355
+
, countMax: null
1356
+
, transitions: []
1357
+
, begin: null
1358
+
, end: null
1359
+
, exclude: []
1360
+
, include: []
1361
+
};
1362
+
1363
+
if ("countMin" in aVal && checkType(aVal.countMin, "number"))
1364
+
options.countMin = aVal.countMin;
1365
+
if ("countMax" in aVal && checkType(aVal.countMax, "number"))
1366
+
options.countMax = aVal.countMax;
1367
+
1368
+
if ("transitions" in aVal &&
1369
+
isValidArray(aVal.transitions, function(v) v.length > 0 && checkArrayElementsType(v, "number")))
1370
+
options.transitions = aVal.transitions;
1371
+
1372
+
if ("begin" in aVal && checkType(aVal.begin, "date"))
1373
+
options.begin = aVal.begin;
1374
+
1375
+
if ("end" in aVal && checkType(aVal.end, "date"))
1376
+
options.end = aVal.end;
1377
+
1378
+
if ("excludeRedirectSources" in aVal &&
1379
+
checkType(aVal.excludeRedirectSources, "boolean"))
1380
+
options.excludeRedirectSources = aVal.excludeRedirectSources;
1381
+
1382
+
if ("excludeRedirectTargets" in aVal &&
1383
+
checkType(aVal.excludeRedirectTargets, "boolean"))
1384
+
options.excludeRedirectTargets = aVal.excludeRedirectTargets;
1385
+
1386
+
if ("includeHidden" in aVal && checkType(aVal.includeHidden, "boolean"))
1387
+
options.includeHidden = aVal.includeHidden;
1388
+
1389
+
if ("includeAllVisits" in aVal && checkType(aVal.includeAllVisits, "boolean"))
1390
+
options.includeAllVisits = aVal.includeAllVisits;
1391
+
1392
+
this._visited = options;
1393
+
}
1394
+
// Set simple bool for isVisited with no other parameters.
1395
+
else if(aVal) {
1396
+
this._visited = true;
1397
+
}
1398
+
return this._visited;
1399
+
},
1400
+
1401
+
// TODO: not yet implemented for callers. Internally
1402
+
// it's used already, so just disabling the setter.
1403
+
_group: "none",
1404
+
get group() this._group,
1405
+
/*
1406
+
set group(aVal)
1407
+
{
1408
+
if (["none", "containers"
1409
+
//, "tags", "month", "year", "host"
1410
+
].indexOf(aVal) != -1)
1411
+
this._group = aVal;
1412
+
return this._group;
1413
+
},
1414
+
*/
1415
+
1416
+
_sortBy: "none",
1417
+
get sortBy() this._sortBy,
1418
+
set sortBy(aVal)
1419
+
{
1420
+
let sortingOptions = ["none", "title", "time", "uri", "accessCount", "lastModified", "frecency"];
1421
+
if (checkType(aVal, "string") && sortingOptions.indexOf(aVal) != -1) {
1422
+
this._sortBy = aVal;
1423
+
}
1424
+
return this._sortBy;
1425
+
},
1426
+
1427
+
_sortDir: "ASC",
1428
+
get sortDir() this._sortDir,
1429
+
set sortDir(aVal)
1430
+
{
1431
+
this._sortDir = ["asc", "desc"].indexOf(aVal) != -1 ? aVal.toUpperCase() : "ASC";
1432
+
return this._sortDir;
1433
+
},
1434
+
1435
+
_limit: -1,
1436
+
get limit() this._limit,
1437
+
set limit(aVal)
1438
+
{
1439
+
if (checkType(aVal, "number"))
1440
+
this._limit = aVal;
1441
+
return this._limit;
1442
+
},
1443
+
1444
+
/*
1445
+
_merge: "union",
1446
+
get merge() this._merge,
1447
+
set merge(aVal)
1448
+
{
1449
+
if (["union", "intersect", "except"].indexOf(aVal) != -1)
1450
+
this._merge = aVal;
1451
+
return this._merge;
1452
+
}
1453
+
*/
1454
+
}
1455
+
1456
+
1457
+
////////////////////////////////////////////////////////////////////////////////
1458
+
//// PlacesQuery
1459
+
1460
+
// Note: Multiple queryconf support is currently denied from callers
1461
+
// as the API is not complete. However, the support is kept in the back-end
1462
+
// so we're just wrapping the query conf in an array in two places
1463
+
// in this ctor for now.
1464
+
function PlacesQuery(aQueryConf)
1465
+
{
1466
+
let queryConfs = [];
1467
+
1468
+
// Allow passing a place: url.
1469
+
if (checkType(aQueryConf, "string") &&
1470
+
aQueryConf.substr(0, 6) == "place:") {
1471
+
queryConfs.push(deserializeLegacyPlaceUrl(aQueryConf));
1472
+
// TODO: check valid conf object here
1473
+
}
1474
+
// Allow array for future compat, but currently
1475
+
// only accepting single query.
1476
+
//else if (checkType(aQueryConf, "array"))
1477
+
// queryConfs.push(new QueryConf(aQueryConf[0]));
1478
+
else if (checkType(aQueryConf, "object"))
1479
+
queryConfs.push(new QueryConf(aQueryConf));
1480
+
else
1481
+
throw Cr.NS_ERROR_INVALID_ARG; // TODO: nice errors please.
1482
+
1483
+
let pendingQuery = this;
1484
+
this.execute = function PQ_execute(aCallback, aThisObject)
1485
+
{
1486
+
// A callback is required, otherwise running the query would be useless.
1487
+
if (!aCallback || !checkType(aCallback, "function"))
1488
+
throw Cr.NS_ERROR_INVALID_ARG; // TODO: nice errors please.
1489
+
1490
+
let [sql, stmt] = QueryBuilder.build(queryConfs);
1491
+
1492
+
// DEBUG
1493
+
//dump("\nDEBUG SQL PRINT\n" + sql + "\n\n");
1494
+
1495
+
// Run query, call back.
1496
+
let stmtCallback = new StmtCallback(queryConfs, aCallback, aThisObject);
1497
+
pendingQuery._pending = stmt.executeAsync(stmtCallback);
1498
+
stmtCallback.pendingQuery = pendingQuery;
1499
+
stmt.finalize();
1500
+
}
1501
+
1502
+
this.cancel = function PQ_cancel()
1503
+
{
1504
+
if (pendingQuery._pending) {
1505
+
pendingQuery._pending.cancel();
1506
+
delete pendingQuery._pending;
1507
+
}
1508
+
}
1509
+
}
1510
+
1511
+
PlacesQuery.prototype = {}
1512
+
1513
+
1514
+
////////////////////////////////////////////////////////////////////////////////
1515
+
//// QueryBuilder
1516
+
1517
+
let QueryBuilder = {
1518
+
build: function QB_build(aQueryConfs)
1519
+
{
1520
+
// Get global options, we use the first query's ones.
1521
+
let globalGroup = aQueryConfs[0].group;
1522
+
let globalSortBy = aQueryConfs[0].sortBy;
1523
+
let globalSortDir = aQueryConfs[0].sortDir;
1524
+
let globalLimit = aQueryConfs[0].limit;
1525
+
1526
+
// Optimizations will come later, but some query could be hard to silent.
1527
+
let sql = "/* do not warn (bug 522572) */";
1528
+
for (let i = 0; i < aQueryConfs.length; i++) {
1529
+
aQueryConfs[i]._qIndex = i;
1530
+
if (i > 0) {
1531
+
switch (aQueryConfs[i - 1].merge) {
1532
+
case "intersect":
1533
+
sql += " INSERSECT ";
1534
+
break;
1535
+
case "except":
1536
+
sql += " EXCEPT ";
1537
+
break;
1538
+
case "union":
1539
+
default:
1540
+
sql += " UNION ";
1541
+
break;
1542
+
}
1543
+
}
1544
+
sql += this._SQLFor(aQueryConfs[i], globalGroup);
1545
+
}
1546
+
1547
+
if (globalSortBy || globalSortDir) {
1548
+
function getNeutralSorting() {
1549
+
if (globalGroup == "containers" || globalGroup == "tags")
1550
+
return "position";
1551
+
return "page_id";
1552
+
}
1553
+
const COLUMNS = { none: getNeutralSorting()
1554
+
, title: "page_title COLLATE NOCASE"
1555
+
, time: "visit_date"
1556
+
, uri: "page_url"
1557
+
, accessCount: "visit_count"
1558
+
, lastModified: "lastModified"
1559
+
, frecency: "frecency"
1560
+
};
1561
+
sql += " ORDER BY " + COLUMNS[globalSortBy] + " " + globalSortDir;
1562
+
}
1563
+
1564
+
// Check if we can apply a direct LIMIT to the query, if there is any sort
1565
+
// of post filtering or processing, we clearly can't.
1566
+
if (globalLimit != -1) {
1567
+
let canSQLLimit = globalGroup == "none";
1568
+
for (let i = 0; i < aQueryConfs.length && canSQLLimit; i++) {
1569
+
canSQLLimit = aQueryConfs[i]._postFilteringTasks.length == 0 &&
1570
+
aQueryConfs[i]._postProcessingTasks.length == 0;
1571
+
}
1572
+
if (canSQLLimit)
1573
+
sql += " LIMIT " + globalLimit;
1574
+
}
1575
+
1576
+
let stmt = DB.createAsyncStatement(sql);
1577
+
this._bind(stmt, aQueryConfs);
1578
+
1579
+
return [sql, stmt];
1580
+
},
1581
+
1582
+
_bind: function QB__bind(aStmt, aQueryConfs)
1583
+
{
1584
+
// Collect all binding params.
1585
+
let params = [];
1586
+
aQueryConfs.forEach(function(aQueryConf) {
1587
+
params = params.concat(aQueryConf._params);
1588
+
});
1589
+
1590
+
params.forEach(function(aParam) {
1591
+
let value = aParam.value;
1592
+
if (checkType(value, "object") &&
1593
+
TextMatch.prototype.isPrototypeOf(value)) {
1594
+
// This is a LIKE clause, thus value must be escaped.
1595
+
aStmt.params[aParam.name] = value.getStringForLike(aStmt);
1596
+
}
1597
+
else {
1598
+
aStmt.params[aParam.name] = value;
1599
+
}
1600
+
});
1601
+
},
1602
+
1603
+
_SQLFor: function QB__SQLFor(aQueryConf, aGroup)
1604
+
{
1605
+
aQueryConf._params = [];
1606
+
aQueryConf._postFilteringTasks = [];
1607
+
aQueryConf._postProcessingTasks = [];
1608
+
1609
+
// Used in all queries.
1610
+
aQueryConf._params.push({ name: "tags_folder",
1611
+
value: PlacesUtils.tagsFolderId });
1612
+
1613
+
if (aQueryConf.visited && aQueryConf.visited.includeAllVisits)
1614
+
return this._SQLForVisitsQuery(aQueryConf, aGroup);
1615
+
1616
+
if (aQueryConf.bookmarked)
1617
+
return this._SQLForBookmarksQuery(aQueryConf, aGroup);
1618
+
1619
+
return this._SQLForPagesQuery(aQueryConf, aGroup);
1620
+
},
1621
+
1622
+
_SQLForVisitsQuery: function QB__SQLForVisitsQuery(aQueryConf, aGroup)
1623
+
{
1624
+
let sql
1625
+
= "SELECT h.id AS page_id, h.url AS page_url, "
1626
+
+ "COALESCE(b.title, h.title) AS page_title, h.rev_host AS rev_host, "
1627
+
+ "h.visit_count AS visit_count, v.visit_date AS visit_date, "
1628
+
+ "f.url AS icon_url, v.session AS session, b.id AS item_id, "
1629
+
+ "b.dateAdded AS dateAdded, b.lastModified AS lastModified, "
1630
+
+ "b.parent AS parent_id, " + TAGS_SQL_FRAGMENT + " AS tags, "
1631
+
+ "b.position AS position, b.type AS item_type, "
1632
+
+ "h.frecency AS frecency, v.id AS visit_id, "
1633
+
+ "v.from_visit AS from_visit, "
1634
+
+ REFERRING_URI_SQL_FRAGMENT + " AS from_visit_uri, "
1635
+
+ "v.visit_type AS visit_type "
1636
+
+ "FROM moz_places h "
1637
+
+ "JOIN moz_historyvisits v ON v.place_id = h.id "
1638
+
+ "LEFT JOIN moz_bookmarks b ON b.fk = h.id "
1639
+
+ "LEFT JOIN moz_favicons f ON f.id = h.favicon_id "
1640
+
;
1641
+
1642
+
return sql + this._getConditions([], aQueryConf, "visits", aGroup);
1643
+
},
1644
+
1645
+
_SQLForPagesQuery: function QB__SQLForPagesQuery(aQueryConf, aGroup)
1646
+
{
1647
+
let sql
1648
+
= "SELECT h.id AS page_id, h.url AS page_url, "
1649
+
+ "COALESCE(b.title, h.title) AS page_title, h.rev_host AS rev_host, "
1650
+
+ "h.visit_count AS visit_count, h.last_visit_date AS visit_date, "
1651
+
+ "f.url AS icon_url, NULL AS session, b.id AS item_id, "
1652
+
+ "b.dateAdded AS dateAdded, b.lastModified AS lastModified, "
1653
+
+ "b.parent AS parent_id, " + TAGS_SQL_FRAGMENT + " AS tags, "
1654
+
+ "b.position AS position, b.type AS item_type, "
1655
+
+ "h.frecency AS frecency, NULL AS visit_id, NULL AS from_visit, "
1656
+
+ "NULL AS from_visit_uri, NULL AS visit_type "
1657
+
+ "FROM moz_places h "
1658
+
+ "LEFT JOIN moz_bookmarks b ON b.fk = h.id "
1659
+
+ "LEFT JOIN moz_favicons f ON f.id = h.favicon_id "
1660
+
;
1661
+
1662
+
return sql + this._getConditions([], aQueryConf, "pages", aGroup);
1663
+
},
1664
+
1665
+
_SQLForBookmarksQuery: function QB__SQLForBookmarksQuery(aQueryConf, aGroup)
1666
+
{
1667
+
// If we are grouping, or querying a folder's contents, show containers.
1668
+
let showContainers = (aGroup != "none" ||
1669
+
(aQueryConf.bookmarked && aQueryConf.bookmarked.folder));
1670
+
let join = showContainers ? "LEFT JOIN" : "JOIN";
1671
+
1672
+
let sql
1673
+
= "SELECT h.id AS page_id, h.url AS page_url, "
1674
+
+ "COALESCE(b.title, h.title) AS page_title, h.rev_host AS rev_host, "
1675
+
+ "h.visit_count AS visit_count, h.last_visit_date AS visit_date, "
1676
+
+ "f.url AS icon_url, NULL AS session, b.id AS item_id, "
1677
+
+ "b.dateAdded AS dateAdded, b.lastModified AS lastModified, "
1678
+
+ "b.parent AS parent_id, " + TAGS_SQL_FRAGMENT + " AS tags, "
1679
+
+ "b.position AS position, b.type AS item_type, "
1680
+
+ "h.frecency AS frecency, NULL AS visit_id, NULL AS from_visit, "
1681
+
+ "NULL AS from_visit_uri, NULL AS visit_type "
1682
+
+ "FROM moz_bookmarks b "
1683
+
+ join + " moz_places h ON b.fk = h.id "
1684
+
+ "LEFT JOIN moz_favicons f ON f.id = h.favicon_id "
1685
+
;
1686
+
1687
+
let conditions = []
1688
+
//if (aGroup == "none") {
1689
+
if (!showContainers) {
1690
+
// We want a flat list, exclude query containers.
1691
+
conditions.push("SUBSTR(page_url, 0, 6) <> 'place:'");
1692
+
}
1693
+
1694
+
return sql + this._getConditions(conditions, aQueryConf, "bookmarks", aGroup);
1695
+
},
1696
+
1697
+
_getConditions: function QB__getConditions(aConditions, aQueryConf, aBaseQuery, aGroup)
1698
+
{
1699
+
// We can use LIKE only for ASCII searches, for anything other we must
1700
+
// fallback to post-filtering. Otherwise we should bundle a lib like ICU.
1701
+
// Moreover searching "bàr" won't match "bar" and viceversa.
1702
+
function needsRegExpLIKE(aText) /[^a-z0-9]/i.test(aText);
1703
+
1704
+
1705
+
if (aQueryConf.phrase) {
1706
+
let textMatch = aQueryConf._phrase;
1707
+
if (needsRegExpLIKE(aQueryConf.phrase)) {
1708
+
aQueryConf._postFilteringTasks.push(function filter(aResultItem) {
1709
+
let reTags = textMatch.getRegExp(true);
1710
+
let re = textMatch.getRegExp(false);
1711
+
return re.test(aResultItem.title) ||
1712
+
re.test(aResultItem.uri) ||
1713
+
reTags.test(aResultItem.tags.join(" "));
1714
+
});
1715
+
}
1716
+
else {
1717
+
let param = "phrase" + aQueryConf._qIndex;
1718
+
aConditions.push(
1719
+
"("
1720
+
+ "page_url LIKE :" + param + " ESCAPE '/' OR "
1721
+
+ "page_title LIKE :" + param + " ESCAPE '/' OR "
1722
+
+ "tags LIKE :" + param + " ESCAPE '/' "
1723
+
+ ")"
1724
+
);
1725
+
aQueryConf._params.push({ name: param,
1726
+
value: textMatch });
1727
+
}
1728
+
}
1729
+
1730
+
1731
+
if (aQueryConf.host) {
1732
+
let textMatch = aQueryConf._host;
1733
+
if (needsRegExpLIKE(aQueryConf.host)) {
1734
+
aQueryConf._postFilteringTasks.push(function filter(aResultItem) {
1735
+
let re = textMatch.getRegExp(false);
1736
+
return re.test(aResultItem.host);
1737
+
});
1738
+
}
1739
+
else {
1740
+
let param = "revHost" + aQueryConf._qIndex;
1741
+
aConditions.push("(rev_host LIKE :" + param + " ESCAPE '/')");
1742
+
let value = textMatch.value.split("").reverse().join("");
1743
+
if (textMatch.exactMatch)
1744
+
value = "^" + value + ".$";
1745
+
else if (textMatch.matchBegin)
1746
+
value = value + ".$";
1747
+
else if (textMatch.matchEnd)
1748
+
value = "^" + value;
1749
+
aQueryConf._params.push({ name: param,
1750
+
value: new TextMatch(value) });
1751
+
}
1752
+
}
1753
+
1754
+
1755
+
if (aQueryConf.uri) {
1756
+
let textMatch = aQueryConf._uri;
1757
+
if (needsRegExpLIKE(aQueryConf.uri)) {
1758
+
aQueryConf._postFilteringTasks.push(function filter(aResultItem) {
1759
+
let re = textMatch.getRegExp(false);
1760
+
return re.test(aResultItem.uri);
1761
+
});
1762
+
}
1763
+
else {
1764
+
let param = "uri" + aQueryConf._qIndex;
1765
+
aConditions.push("(page_url LIKE :" + param + " ESCAPE '/')");
1766
+
aQueryConf._params.push({ name: param,
1767
+
value: textMatch });
1768
+
}
1769
+
}
1770
+
1771
+
1772
+
if (aQueryConf.bookmarked) {
1773
+
let options = aQueryConf.bookmarked;
1774
+
1775
+
// Exclude bookmarks in tags folders.
1776
+
aConditions.push(
1777
+
"NOT EXISTS ("
1778
+
+ "SELECT 1 FROM moz_bookmarks parents "
1779
+
+ "WHERE parents.id = parent_id AND parents.parent = :tags_folder "
1780
+
+ "LIMIT 1 "
1781
+
+ ") "
1782
+
);
1783
+
1784
+
if (checkType(options, "object")) {
1785
+
1786
+
if (options.tags.length > 0) {
1787
+
// tags filtering.
1788
+
let paramPrefix = "tag" + aQueryConf._qIndex;
1789
+
let params = [];
1790
+
for (let i = 0; i < options.tags.length; i++) {
1791
+
let param = paramPrefix + "_" + i
1792
+
params.push(":" + param);
1793
+
aQueryConf._params.push({ name: param,
1794
+
value: options.tags[i] });
1795
+
}
1796
+
let param = "tagsCount" + aQueryConf._qIndex;
1797
+
aQueryConf._params.push({ name: param,
1798
+
value: options.tags.length });
1799
+
aConditions.push(
1800
+
":" + param + " = ( "
1801
+
+ "SELECT count(*) FROM moz_bookmarks tags_map "
1802
+
+ "JOIN moz_bookmarks tags ON tags_map.parent = tags.id "
1803
+
+ "WHERE tags.parent = :tags_folder "
1804
+
+ "AND tags.title IN (" + params.join(",") + ") "
1805
+
+ "AND tags_map.fk = page_id "
1806
+
+ ") "
1807
+
);
1808
+
}
1809
+
1810
+
if (options.folder) {
1811
+
// folder id filtering.
1812
+
let param = "folderId" + aQueryConf._qIndex;
1813
+
aConditions.push("parent_id = :" + param);
1814
+
aQueryConf._params.push({ name: param,
1815
+
value: options.folder });
1816
+
if (checkType(options.position, "number")) {
1817
+
// position in folder filtering.
1818
+
let param = "positionInFolder" + aQueryConf._qIndex;
1819
+
aConditions.push("position = :" + param);
1820
+
aQueryConf._params.push({ name: param,
1821
+
value: options.position });
1822
+
}
1823
+
}
1824
+
1825
+
if (options.id) {
1826
+
// id filtering.
1827
+
let param = "itemId" + aQueryConf._qIndex;
1828
+
aConditions.push("item_id = :" + param);
1829
+
aQueryConf._params.push({ name: param,
1830
+
value: options.id });
1831
+
}
1832
+
1833
+
if (options.createdBegin) {
1834
+
let param = "createdBeginTime" + aQueryConf._qIndex;
1835
+
let beginTime = options.createdBegin.getTime() * 1000;
1836
+
aConditions.push("dateAdded >= :" + param);
1837
+
aQueryConf._params.push({ name: param,
1838
+
value: beginTime });
1839
+
}
1840
+
if (options.createdEnd) {
1841
+
let param = "createdEndTime" + aQueryConf._qIndex;
1842
+
let endTime = options.createdEnd.getTime() * 1000;
1843
+
aConditions.push("dateAdded <= :" + param);
1844
+
aQueryConf._params.push({ name: param,
1845
+
value: endTime });
1846
+
}
1847
+
1848
+
if (options.modifiedBegin) {
1849
+
let param = "modifiedBeginTime" + aQueryConf._qIndex;
1850
+
let beginTime = options.modifiedBegin.getTime() * 1000;
1851
+
aConditions.push("lastModified >= :" + param);
1852
+
aQueryConf._params.push({ name: param,
1853
+
value: beginTime });
1854
+
}
1855
+
if (options.modifiedEnd) {
1856
+
let param = "modifiedEndTime" + aQueryConf._qIndex;
1857
+
let endTime = options.modifiedEnd.getTime() * 1000;
1858
+
aConditions.push("lastModified <= :" + param);
1859
+
aQueryConf._params.push({ name: param,
1860
+
value: endTime });
1861
+
}
1862
+
1863
+
if (options.excludeReadOnlyContainers) {
1864
+
// Exclude queries and folders annotated as read-only.
1865
+
aConditions.push("SUBSTR(page_url, 0, 6) <> 'place:'");
1866
+
aConditions.push(
1867
+
"NOT EXISTS( "
1868
+
+ "SELECT 1 FROM moz_items_annos a "
1869
+
+ "JOIN moz_anno_attributes n ON n.id = a.anno_attribute_id "
1870
+
+ "WHERE a.item_id = b.id AND n.name = :readOnlyAnno "
1871
+
+ "LIMIT 1 "
1872
+
+ ")"
1873
+
);
1874
+
aQueryConf._params.push({ name: "readOnlyAnno",
1875
+
value: PlacesUtils.READ_ONLY_ANNO });
1876
+
}
1877
+
1878
+
if (options.onlyContainers) {
1879
+
aConditions.push(
1880
+
"(item_type <> :bookmark_type OR "
1881
+
+ "(page_url >= 'place:' AND page_url < 'place;') "
1882
+
+ ")"
1883
+
);
1884
+
aConditions.push("item_type <> :separator_type");
1885
+
aQueryConf._params.push({ name: "separator_type",
1886
+
value: PlacesUtils.bookmarks.TYPE_SEPARATOR });
1887
+
}
1888
+
1889
+
}
1890
+
}
1891
+
1892
+
1893
+
if (aQueryConf.visited) {
1894
+
if (aBaseQuery != "visits") {
1895
+
aConditions.push(
1896
+
"EXISTS (SELECT id FROM moz_historyvisits WHERE place_id = h.id LIMIT 1)"
1897
+
);
1898
+
}
1899
+
let options = aQueryConf.visited;
1900
+
1901
+
if (checkType(options, "object")) {
1902
+
if (options.countMin) {
1903
+
let param = "minVisitCount" + aQueryConf._qIndex;
1904
+
aConditions.push("visit_count >= :" + param);
1905
+
aQueryConf._params.push({ name: param,
1906
+
value: options.countMin });
1907
+
}
1908
+
if (options.countMax) {
1909
+
let param = "maxVisitCount" + aQueryConf._qIndex;
1910
+
aConditions.push("visit_count <= :" + param);
1911
+
aQueryConf._params.push({ name: param,
1912
+
value: options.countMax });
1913
+
}
1914
+
1915
+
if (options.transitions.length > 0) {
1916
+
let paramPrefix = "transition" + aQueryConf._qIndex;
1917
+
if (aBaseQuery == "visits" && options.transitions.length == 1) {
1918
+
aConditions.push("visit_type = : " + paramPrefix);
1919
+
aQueryConf._params.push({ name: paramPrefix,
1920
+
value: options.transitions[0] });
1921
+
}
1922
+
else {
1923
+
let params = [];
1924
+
for (let i = 0; i < options.transitions.length; i++) {
1925
+
let param = paramPrefix + "_" + i
1926
+
params.push(":" + param);
1927
+
aQueryConf._params.push({ name: param,
1928
+
value: options.transitions[i] });
1929
+
aConditions.push(
1930
+
"EXISTS ( "
1931
+
+ "SELECT 1 FROM moz_historyvisits "
1932
+
+ "WHERE place_id = page_id AND visit_type = :" + param + " "
1933
+
+ "LIMIT 1 "
1934
+
+ ")"
1935
+
);
1936
+
}
1937
+
}
1938
+
}
1939
+
1940
+
if (options.begin) {
1941
+
let param = "visitedBeginTime" + aQueryConf._qIndex;
1942
+
let beginTime = options.begin.getTime() * 1000;
1943
+
aQueryConf._params.push({ name: param,
1944
+
value: beginTime });
1945
+
if (aBaseQuery == "visits") {
1946
+
aConditions.push("visit_date >= :" + param);
1947
+
}
1948
+
else {
1949
+
aConditions.push(
1950
+
"EXISTS( "
1951
+
+ "SELECT 1 FROM moz_historyvisits "
1952
+
+ "WHERE visit_date >= :" + param + " AND place_id = page_id "
1953
+
+ "LIMIT 1 "
1954
+
+ ")"
1955
+
);
1956
+
}
1957
+
}
1958
+
if (options.end) {
1959
+
let param = "visitedEndTime" + aQueryConf._qIndex;
1960
+
let endTime = options.end.getTime() * 1000;
1961
+
aQueryConf._params.push({ name: param,
1962
+
value: endTime });
1963
+
if (aBaseQuery == "visits") {
1964
+
aConditions.push("visit_date <= :" + param);
1965
+
}
1966
+
else {
1967
+
aConditions.push(
1968
+
"EXISTS( "
1969
+
+ "SELECT 1 FROM moz_historyvisits "
1970
+
+ "WHERE visit_date <= :" + param + " AND place_id = page_id "
1971
+
+ "LIMIT 1 "
1972
+
+ ")"
1973
+
);
1974
+
}
1975
+
}
1976
+
1977
+
if (options.excludeRedirectSources) {
1978
+
aQueryConf._params.push({ name: "transition_redirect_permanent",
1979
+
value: Ci.nsINavHistoryService.TRANSITION_REDIRECT_PERMANENT });
1980
+
aQueryConf._params.push({ name: "transition_redirect_temporary",
1981
+
value: Ci.nsINavHistoryService.TRANSITION_REDIRECT_TEMPORARY });
1982
+
if (aBaseQuery == "visits") {
1983
+
aConditions.push(
1984
+
"NOT EXISTS ( "
1985
+
+ "SELECT id FROM moz_historyvisits "
1986
+
+ "WHERE from_visit = visit_id AND visit_type IN (:transition_redirect_permanent, :transition_redirect_temporary) "
1987
+
+ ")"
1988
+
);
1989
+
}
1990
+
else {
1991
+
// Exclude pages that are only redirect sources.
1992
+
aConditions.push(
1993
+
"EXISTS ( "
1994
+
+ "SELECT 1 FROM moz_historyvisits srcs "
1995
+
+ "LEFT JOIN moz_historyvisits dests ON dests.from_visit = srcs.id "
1996
+
+ "WHERE srcs.place_id = page_id "
1997
+
+ "AND (dests.id IS NULL OR dests.visit_type NOT IN (:transition_redirect_permanent, :transition_redirect_temporary)) "
1998
+
+ "LIMIT 1 "
1999
+
+ ")"
2000
+
);
2001
+
}
2002
+
}
2003
+
2004
+
if (options.excludeRedirectTargets) {
2005
+
aQueryConf._params.push({ name: "transition_redirect_permanent",
2006
+
value: Ci.nsINavHistoryService.TRANSITION_REDIRECT_PERMANENT });
2007
+
aQueryConf._params.push({ name: "transition_redirect_temporary",
2008
+
value: Ci.nsINavHistoryService.TRANSITION_REDIRECT_TEMPORARY });
2009
+
if (aBaseQuery == "visits") {
2010
+
aConditions.push(
2011
+
"visit_type NOT IN (:transition_redirect_permanent, :transition_redirect_temporary)"
2012
+
);
2013
+
}
2014
+
else {
2015
+
// Exclude pages that are only redirect targets.
2016
+
aConditions.push(
2017
+
"EXISTS ( "
2018
+
+ "SELECT 1 FROM moz_historyvisits "
2019
+
+ "WHERE place_id = page_id "
2020
+
+ "AND visit_type NOT IN (:transition_redirect_permanent, :transition_redirect_temporary) "
2021
+
+ "LIMIT 1 "
2022
+
+ ")"
2023
+
);
2024
+
}
2025
+
}
2026
+
2027
+
if (!options.includeHidden) {
2028
+
aConditions.push("h.hidden = 0");
2029
+
if (aBaseQuery == "visits") {
2030
+
aConditions.push(
2031
+
"visit_type NOT IN (:transition_embed, :transition_framed_link)"
2032
+
);
2033
+
aQueryConf._params.push({ name: "transition_embed",
2034
+
value: Ci.nsINavHistoryService.TRANSITION_EMBED });
2035
+
aQueryConf._params.push({ name: "transition_framed_link",
2036
+
value: Ci.nsINavHistoryService.TRANSITION_FRAMED_LINK });
2037
+
}
2038
+
}
2039
+
}
2040
+
}
2041
+
2042
+
2043
+
if (aQueryConf.annotated.length > 0) {
2044
+
let paramPrefix = "annoName" + aQueryConf._qIndex;
2045
+
let params = [];
2046
+
for (let i = 0; i < aQueryConf.annotated.length; i++) {
2047
+
let param = paramPrefix + "_" + i;
2048
+
params.push(":" + param);
2049
+
aQueryConf._params.push({ name: param,
2050
+
value: aQueryConf.annotated[i] });
2051
+
}
2052
+
let param = "annosCount" + aQueryConf._qIndex;
2053
+
aQueryConf._params.push({ name: param,
2054
+
value: aQueryConf.annotated.length });
2055
+
aConditions.push(
2056
+
":" + param + " = ( "
2057
+
+ "SELECT count(*) FROM moz_anno_attributes n "
2058
+
+ "LEFT JOIN moz_annos a ON n.id = a.anno_attribute_id AND a.place_id = h.id "
2059
+
+ "LEFT JOIN moz_items_annos ia ON n.id =ia.anno_attribute_id AND ia.item_id = b.id "
2060
+
+ "WHERE name IN (" + params.join(",") + ") "
2061
+
+ "AND IFNULL(place_id, item_id) NOTNULL "
2062
+
+ ") "
2063
+
);
2064
+
}
2065
+
2066
+
2067
+
return aConditions.length > 0 ? "WHERE " + aConditions.join(" AND ")
2068
+
: "";
2069
+
}
2070
+
}
2071
+
2072
+
////////////////////////////////////////////////////////////////////////////////
2073
+
//// StmtCallback
2074
+
2075
+
function StmtCallback(aQueryConfs, aCallback, aThisObject)
2076
+
{
2077
+
this._queryConfs = aQueryConfs;
2078
+
this._callbackInfo = { cb: aCallback, scope: aThisObject };
2079
+
this._results = [];
2080
+
this._limit = aQueryConfs[0].limit;
2081
+
this._currentResultsCount = 0;
2082
+
this.pendingQuery = null;
2083
+
2084
+
// Collect all post-filtering tasks. These are run as soon as results are
2085
+
// available. Filtered results are then immediately returned to the caller
2086
+
// unless post-processing has to happen.
2087
+
this._postFilteringTasks = [];
2088
+
this._queryConfs.forEach(function(aQueryConf) {
2089
+
this._postFilteringTasks =
2090
+
this._postFilteringTasks.concat(aQueryConf._postFilteringTasks.slice());
2091
+
}, this);
2092
+
2093
+
// Collect all post-processing tasks. These are run after all results have
2094
+
// been cached. If any post-processing task is defined then no results are
2095
+
// returned to the caller till all post-processing is finished.
2096
+
this._postProcessingTasks = [];
2097
+
this._queryConfs.forEach(function(aQueryConf) {
2098
+
this._postProcessingTasks =
2099
+
this._postProcessingTasks.concat(aQueryConf._postProcessingTasks.slice());
2100
+
}, this);
2101
+
}
2102
+
2103
+
StmtCallback.prototype = {
2104
+
handleResult: function SC_handleResult(aResultSet)
2105
+
{
2106
+
let row;
2107
+
let results = [];
2108
+
while ((row = aResultSet.getNextRow()) != null) {
2109
+
results.push(new ResultItem(row, this._queryConfs));
2110
+
}
2111
+
2112
+
this._postFilter(results);
2113
+
2114
+
this._currentResultsCount += results.length;
2115
+
if (this._limit != -1 && this._postProcessingTasks.length == 0 &&
2116
+
this._currentResultsCount >= this._limit) {
2117
+
// No reason for this query to return other results.
2118
+
if (this.pendingQuery)
2119
+
this.pendingQuery.cancel();
2120
+
// Remove exceeding results.
2121
+
let excess = this._currentResultsCount - this._limit;
2122
+
results.splice(results.length - excess, excess);
2123
+
}
2124
+
2125
+
// If this query does not require postProcessing, just push results to the
2126
+
// caller. Notice that pushing an empty result set means that we are done
2127
+
// so we must avoid it.
2128
+
if (this._postProcessingTasks.length == 0 && results.length > 0)
2129
+
this._callback(results);
2130
+
else
2131
+
this._results = this._results.concat(results);
2132
+
},
2133
+
2134
+
handleError: function SC_handleError(aError)
2135
+
{
2136
+
Cu.reportError("PlacesQuery: An error occured while executing a query.");
2137
+
},
2138
+
2139
+
handleCompletion: function SC_handleCompletion(aReason)
2140
+
{
2141
+
if (aReason == Ci.mozIStorageStatementCallback.REASON_FINISHED ||
2142
+
aReason == Ci.mozIStorageStatementCallback.REASON_CANCELED &&
2143
+
this._results.length > 0) {
2144
+
this._postProcess(this._results);
2145
+
2146
+
if (this._limit != -1 && this._results.length > this._limit) {
2147
+
// Remove exceeding results.
2148
+
let excess = this._results.length - this._limit;
2149
+
this._results.splice(this._results.length - excess, excess);
2150
+
}
2151
+
}
2152
+
2153
+
// Notify the caller we have finished pushing results, by pushing an empty
2154
+
// set. This happens regardless completion reason.
2155
+
this._callback(this._results);
2156
+
},
2157
+
2158
+
_postProcess: function SC__postProcess(aResults) {
2159
+
// Bail out if there is nothing to post-process.
2160
+
if (this._postProcessingTasks.length == 0)
2161
+
return;
2162
+
2163
+
for (let i = 0; i < this._results.length; i++) {
2164
+
this._postProcessingTasks.forEach(function(aPPTask) {
2165
+
// Each post-processing task should be able to work on the full set.
2166
+
aPPTask(this._results); // TODO: define this better.
2167
+
}, this);
2168
+
}
2169
+
2170
+
// Push results to the caller, if we have any.
2171
+
if (aResults.length)
2172
+
this._callback(aResults);
2173
+
},
2174
+
2175
+
_postFilter: function SC__postFilter(aResults) {
2176
+
// Bail out if there is nothing to post-filter.
2177
+
if (this._postFilteringTasks.length == 0)
2178
+
return;
2179
+
2180
+
for (let i = 0; i < aResults.length; i++) {
2181
+
this._postFilteringTasks.forEach(function(aPassFilter) {
2182
+
if (!aPassFilter(aResults[i])) {
2183
+
// Be sure to decrease i since we are removing one element.
2184
+
aResults.splice(i--, 1);
2185
+
}
2186
+
}, this);
2187
+
}
2188
+
},
2189
+
2190
+
_callback: function SC__callback(aResults) {
2191
+
// Enqueue the call, so it runs out of the current task.
2192
+
Services.tm.mainThread.dispatch({
2193
+
_callbackInfo: this._callbackInfo,
2194
+
run: function() {
2195
+
let callback = this._callbackInfo.cb;
2196
+
let scope = this._callbackInfo.scope ||
2197
+
Cu.getGlobalForObject(this._callbackInfo.cb);
2198
+
// If there are results, call the callback for each individual result.
2199
+
if (aResults.length)
2200
+
aResults.forEach(callback, scope);
2201
+
// Otherwise, the query must be complete.
2202
+
else
2203
+
callback.call(scope, false);
2204
+
}
2205
+
}, Ci.nsIThread.DISPATCH_NORMAL);
2206
+
}
2207
+
}
2208
+
2209
+
2210
+
////////////////////////////////////////////////////////////////////////////////
2211
+
//// ResultItem
2212
+
2213
+
function ResultItem(aResultRow, aQueryConfs){
2214
+
if (!(aResultRow instanceof Ci.mozIStorageRow))
2215
+
return;
2216
+
this.pageId = aResultRow.getResultByName("page_id");
2217
+
this.uri = aResultRow.getResultByName("page_url");
2218
+
this.title = aResultRow.getResultByName("page_title");
2219
+
let revHost = aResultRow.getResultByName("rev_host");
2220
+
this.host = revHost ? revHost.split("").reverse().join("").substr(1) : "";
2221
+
this.accessCount = aResultRow.getResultByName("visit_count");
2222
+
// TODO: if there is a time constraint time should be the last visit in
2223
+
// that time instead.
2224
+
this.time = new Date(aResultRow.getResultByName("visit_date")/1000);
2225
+
this.icon = aResultRow.getResultByName("icon_url");
2226
+
this.sessionId = aResultRow.getResultByName("session");
2227
+
this.itemId = aResultRow.getResultByName("item_id");
2228
+
this.isBookmarked = !!this.itemId;
2229
+
this.dateAdded = new Date(aResultRow.getResultByName("dateAdded")/1000);
2230
+
this.lastModified = new Date(aResultRow.getResultByName("lastModified")/1000);
2231
+
this.parentId = aResultRow.getResultByName("parent_id");
2232
+
let tags = aResultRow.getResultByName("tags");
2233
+
this.tags = tags ? tags.split(TAGS_SEPARATOR) : [];
2234
+
this.bookmarkIndex = aResultRow.getResultByName("position");
2235
+
this.frecency = aResultRow.getResultByName("frecency");
2236
+
this.visitId = aResultRow.getResultByName("visit_id");
2237
+
this.referringVisitId = aResultRow.getResultByName("from_visit");
2238
+
this.referringUri = aResultRow.getResultByName("from_visit_uri");
2239
+
this.transitionType = aResultRow.getResultByName("visit_type");
2240
+
let itemType = aResultRow.getResultByName("item_type");
2241
+
this.type = getNodeType(this, itemType);
2242
+
this.readableType = getReadableItemType(this, itemType);
2243
+
2244
+
let currentResult = this;
2245
+
// Index of the query that generated this result.
2246
+
2247
+
XPCOMUtils.defineLazyGetter(this, "query", function() {
2248
+
if (currentResult.readableType != "container")
2249
+
throw new Error("Cannot get query for a non container.");
2250
+
2251
+
if (currentResult.type == Ci.nsINavHistoryResultNode.RESULT_TYPE_QUERY) {
2252
+
// PlacesQuery can deserialize most place: uris.
2253
+
// This is not completely correct, since options from the place: uri and
2254
+
// current ones should be merged.
2255
+
return new PlacesQuery(currentResult.uri);
2256
+
}
2257
+
2258
+
if (currentResult.type == Ci.nsINavHistoryResultNode.RESULT_TYPE_FOLDER) {
2259
+
let queryConfs = [].concat(aQueryConfs);
2260
+
queryConfs.forEach(function(aQueryConf) {
2261
+
aQueryConf.bookmarked.folder = currentResult.itemId;
2262
+
});
2263
+
return new PlacesQuery(queryConfs);
2264
+
}
2265
+
2266
+
throw new Error("Cannot get query for this kind of container.");
2267
+
});
2268
+
}
2269
+
2270
+
ResultItem.prototype = {}
+9
package.json
+9
package.json
+32
test/test-main.js
+32
test/test-main.js
···
1
+
const main = require("main");
2
+
3
+
exports.test_test_run = function(test) {
4
+
test.pass("Unit test running!");
5
+
};
6
+
7
+
exports.test_id = function(test) {
8
+
test.assert(require("self").id.length > 0);
9
+
};
10
+
11
+
exports.test_url = function(test) {
12
+
require("request").Request({
13
+
url: "http://www.mozilla.org/",
14
+
onComplete: function(response) {
15
+
test.assertEqual(response.statusText, "OK");
16
+
test.done();
17
+
}
18
+
}).get();
19
+
test.waitUntilDone(20000);
20
+
};
21
+
22
+
exports.test_open_tab = function(test) {
23
+
const tabs = require("tabs");
24
+
tabs.open({
25
+
url: "http://www.mozilla.org/",
26
+
onReady: function(tab) {
27
+
test.assertEqual(tab.url, "http://www.mozilla.org/");
28
+
test.done();
29
+
}
30
+
});
31
+
test.waitUntilDone(20000);
32
+
};