worthless
'], {type: 'text/html'}); 8 | 9 | var storage = new lls({name: 'lls-urlcache-test', size: 10 * 1024 * 1024}); 10 | LargeLocalStorage.contrib.URLCache.addTo(storage); 11 | var cacheObj = storage.pipe.getHandler('URLCache').cache; 12 | 13 | // for debug 14 | // window.cacheObj = cacheObj; 15 | // window.storage = storage; 16 | 17 | // TODO: spy on LargeLocalStorage to ensure that 18 | // revokeAttachmentURL is being called. 19 | // And also spy to make sure piped methods are receiving their calls. 20 | 21 | function loadTests() { 22 | describe('URLCache', function() { 23 | it('Caches getAttachmentURL operations', 24 | function(done) { 25 | storage.setAttachment('doc', 'attach', blob) 26 | .then(function() { 27 | console.log('Getting attach url'); 28 | return storage.getAttachmentURL('doc', 'attach'); 29 | }) 30 | .then(function(url) { 31 | console.log('Comparison'); 32 | expect(url).to.equal(cacheObj.main.doc.attach); 33 | expect(cacheObj.reverse[url]).to.eql({ 34 | docKey: 'doc', 35 | attachKey: 'attach' 36 | }); 37 | }).done(done); 38 | }); 39 | 40 | it('Removes the URL from the cache when updating the attachment', 41 | function(done) { 42 | storage.setAttachment('doc', 'attach', blob) 43 | .then(function() { 44 | expect(cacheObj.main.doc.attach).to.equal(undefined); 45 | expect(cacheObj.reverse).to.eql({}); 46 | }).done(done); 47 | }); 48 | 49 | it('Removes the URL from the cache when removing the attachment', 50 | function(done) { 51 | var theUrl; 52 | storage.getAttachmentURL('doc', 'attach').then(function(url) { 53 | expect(url).to.equal(cacheObj.main.doc.attach); 54 | theUrl = url; 55 | return storage.rmAttachment('doc', 'attach'); 56 | }).then(function() { 57 | expect(cacheObj.main.doc.attach).to.equal(undefined); 58 | expect(cacheObj.reverse[theUrl]).to.equal(undefined); 59 | }).done(done); 60 | }); 61 | 62 | it('Removes the URL from the cache when removing the attachment via removing the host document', 63 | function(done) { 64 | storage.setAttachment('doc2', 'attach', blob) 65 | .then(function() { 66 | return storage.rm('doc2'); 67 | }).then(function() { 68 | expect(cacheObj.main.doc2).to.equal(undefined); 69 | expect(cacheObj.reverse).to.eql({}); 70 | }).done(done); 71 | }); 72 | 73 | it('Removes the URL from the cache when revoking the URL', 74 | function(done) { 75 | storage.setAttachment('doc3', 'attach', blob) 76 | .then(function() { 77 | return storage.getAttachmentURL('doc3', 'attach'); 78 | }).then(function(url) { 79 | expect(url).to.equal(cacheObj.main.doc3.attach); 80 | expect(cacheObj.reverse[url]).to.eql({ 81 | docKey: 'doc3', 82 | attachKey: 'attach' 83 | }); 84 | storage.revokeAttachmentURL(url); 85 | expect(cacheObj.main.doc3.attach).to.equal(undefined); 86 | expect(cacheObj.reverse).to.eql({}); 87 | }).done(done); 88 | }); 89 | 90 | it('Removes all URLs when emptying the database', 91 | function(done) { 92 | Q.all([storage.setAttachment('doc4', 'attach', blob), 93 | storage.setAttachment('doc5', 'attach', blob)]) 94 | .then(function() { 95 | return storage.clear(); 96 | }).then(function() { 97 | expect(cacheObj.reverse).to.eql({}); 98 | expect(cacheObj.main).to.eql({}); 99 | }).done(done); 100 | }); 101 | }); 102 | } 103 | 104 | loadTests(); 105 | storage.initialized.then(function() { 106 | window.runMocha(); 107 | }); 108 | })(LargeLocalStorage); -------------------------------------------------------------------------------- /examples/album/app.js: -------------------------------------------------------------------------------- 1 | (function() { 2 | 'use strict'; 3 | 4 | var storage = new LargeLocalStorage({ 5 | size: 20 * 1024 * 1024, 6 | name: 'lls-album-example' 7 | // forceProvider: 'IndexedDB' 8 | // forceProvider: 'WebSQL' 9 | }); 10 | 11 | storage.initialized.then(function() { 12 | console.log(storage.getCapacity()); 13 | var $storageNotice = $('.storageNotice'); 14 | $storageNotice.css('opacity', 0); 15 | setTimeout(function() { 16 | $storageNotice.css('display', 'none'); 17 | }, 1100); 18 | 19 | bind(); 20 | }, function() { 21 | console.log('denied'); 22 | }); 23 | 24 | function bind() { 25 | var dndArea = new Album($('.dndArea')); 26 | } 27 | 28 | function Album($el) { 29 | this.$el = $el; 30 | this._drop = this._drop.bind(this); 31 | this._photoAdded = this._photoAdded.bind(this); 32 | this._appendImage = this._appendImage.bind(this); 33 | this.$el.on('dragover', copyDragover); 34 | this.$el.on('drop', this._drop); 35 | this.$thumbs = this.$el.find('.thumbnails'); 36 | this.$usage = this.$el.find('.usage'); 37 | 38 | var self = this; 39 | $('#clear').click(function() { 40 | storage.clear().then(function() { 41 | self.$thumbs.empty(); 42 | }).done(); 43 | }); 44 | 45 | this._renderExistingPhotos(); 46 | } 47 | 48 | Album.prototype = { 49 | _drop: function(e) { 50 | e.stopPropagation(); 51 | e.preventDefault(); 52 | 53 | e = e.originalEvent; 54 | 55 | foreach(this._photoAdded, keep(isImage, e.dataTransfer.files)); 56 | }, 57 | 58 | _photoAdded: function(file) { 59 | // TOOD: see if already exists?? 60 | storage.setAttachment('album', file.name, file) 61 | .then(function() { 62 | return storage.getAttachmentURL('album', file.name); 63 | }).then(this._appendImage); 64 | }, 65 | 66 | _appendImage: function(url) { 67 | if (this.$usage) { 68 | this.$usage.remove(); 69 | this.$usage = null; 70 | } 71 | var container = $(''); 72 | var image = new Image(); 73 | image.src = url; 74 | var self = this; 75 | image.onload = function() { 76 | var scale = 171 / image.naturalWidth; 77 | 78 | var newHeight = scale * image.naturalHeight; 79 | if (newHeight > 180) { 80 | scale = 180 / image.naturalHeight; 81 | newHeight = 180; 82 | } 83 | 84 | var newWidth = scale * image.naturalWidth; 85 | 86 | image.width = newWidth; 87 | image.height = newHeight; 88 | 89 | container.append(image); 90 | self.$thumbs.append(container); 91 | }; 92 | 93 | storage.revokeAttachmentURL(url); 94 | }, 95 | 96 | _renderExistingPhotos: function() { 97 | var self = this; 98 | storage.getAllAttachmentURLs('album') 99 | .then(function(urls) { 100 | urls = urls.map(function(u) { 101 | return u.url; 102 | }); 103 | foreach(self._appendImage, urls); 104 | }); 105 | } 106 | }; 107 | 108 | 109 | function copyDragover(e) { 110 | e.stopPropagation(); 111 | e.preventDefault(); 112 | e = e.originalEvent; 113 | e.dataTransfer.dropEffect = 'copy'; 114 | } 115 | 116 | function foreach(cb, arr) { 117 | for (var i = 0; i < arr.length; ++i) { 118 | cb(arr[i]); 119 | } 120 | } 121 | 122 | function isImage(file) { 123 | return file.type.indexOf('image') == 0; 124 | } 125 | 126 | function keep(pred, arr) { 127 | return filter(not(pred), arr); 128 | } 129 | 130 | function not(pred) { 131 | return function(e) { 132 | return !pred(e); 133 | } 134 | } 135 | 136 | function filter(pred, arr) { 137 | var result = []; 138 | for (var i = 0; i < arr.length; ++i) { 139 | var e = arr[i]; 140 | if (!pred(e)) 141 | result.push(e); 142 | } 143 | 144 | return result; 145 | } 146 | })(); -------------------------------------------------------------------------------- /dist/contrib/URLCache.js: -------------------------------------------------------------------------------- 1 | LargeLocalStorage.contrib.URLCache = (function() { 2 | var defaultOptions = { 3 | manageRevocation: true 4 | }; 5 | 6 | function defaults(options, defaultOptions) { 7 | for (var k in defaultOptions) { 8 | if (options[k] === undefined) 9 | options[k] = defaultOptions[k]; 10 | } 11 | 12 | return options; 13 | } 14 | 15 | function add(docKey, attachKey, url) { 16 | if (this.options.manageRevocation) 17 | expunge.call(this, docKey, attachKey, true); 18 | 19 | var mainCache = this.cache.main; 20 | var docCache = mainCache[docKey]; 21 | if (!docCache) { 22 | docCache = {}; 23 | mainCache[docKey] = docCache; 24 | } 25 | 26 | docCache[attachKey] = url; 27 | this.cache.reverse[url] = {docKey: docKey, attachKey: attachKey}; 28 | } 29 | 30 | function addAll(urlEntries) { 31 | urlEntries.forEach(function(entry) { 32 | add.call(this, entry.docKey, entry.attachKey, entry.url); 33 | }, this); 34 | } 35 | 36 | function expunge(docKey, attachKey, needsRevoke) { 37 | function delAndRevoke(attachKey) { 38 | var url = docCache[attachKey]; 39 | delete docCache[attachKey]; 40 | delete this.cache.reverse[url]; 41 | if (this.options.manageRevocation && needsRevoke) 42 | this.llshandler.revokeAttachmentURL(url, {bypassUrlCache: true}); 43 | } 44 | 45 | var docCache = this.cache.main[docKey]; 46 | if (docCache) { 47 | if (attachKey) { 48 | delAndRevoke.call(this, attachKey); 49 | } else { 50 | for (var attachKey in docCache) { 51 | delAndRevoke.call(this, attachKey); 52 | } 53 | delete this.cache.main[docKey]; 54 | } 55 | } 56 | } 57 | 58 | function expungeByUrl(url) { 59 | var keys = this.cache.reverse[url]; 60 | if (keys) { 61 | expunge.call(this, keys.docKey, keys.attachKey, false); 62 | } 63 | } 64 | 65 | 66 | function URLCache(llspipe, options) { 67 | options = options || {}; 68 | this.options = defaults(options, defaultOptions); 69 | this.llshandler = llspipe.pipe.getHandler('lls'); 70 | this.pending = {}; 71 | this.cache = { 72 | main: {}, 73 | reverse: {} 74 | }; 75 | } 76 | 77 | URLCache.prototype = { 78 | setAttachment: function(docKey, attachKey, blob) { 79 | expunge.call(this, docKey, attachKey); 80 | return this.__pipectx.next(docKey, attachKey, blob); 81 | }, 82 | 83 | rmAttachment: function(docKey, attachKey) { 84 | expunge.call(this, docKey, attachKey); 85 | return this.__pipectx.next(docKey, attachKey); 86 | }, 87 | 88 | rm: function(docKey) { 89 | expunge.call(this, docKey); 90 | return this.__pipectx.next(docKey); 91 | }, 92 | 93 | revokeAttachmentURL: function(url, options) { 94 | if (!options || !options.bypassUrlCache) 95 | expungeByUrl.call(this, url); 96 | 97 | return this.__pipectx.next(url, options); 98 | }, 99 | 100 | getAttachmentURL: function(docKey, attachKey) { 101 | var pendingKey = docKey + attachKey; 102 | var pending = this.pending[pendingKey]; 103 | if (pending) 104 | return pending; 105 | 106 | var promise = this.__pipectx.next(docKey, attachKey); 107 | var self = this; 108 | promise.then(function(url) { 109 | add.call(self, docKey, attachKey, url); 110 | delete self.pending[pendingKey]; 111 | }); 112 | 113 | this.pending[pendingKey] = promise; 114 | 115 | return promise; 116 | }, 117 | 118 | // TODO: pending between this and getAttachmentURL... 119 | // Execute this as an ls and then 120 | // a loop on getAttachmentURL instead??? 121 | // doing it the way mentiond above 122 | // will prevent us from leaking blobs. 123 | getAllAttachmentURLs: function(docKey) { 124 | var promise = this.__pipectx.next(docKey); 125 | var self = this; 126 | promise.then(function(urlEntries) { 127 | addAll.call(self, urlEntries); 128 | }); 129 | 130 | return promise; 131 | }, 132 | 133 | clear: function() { 134 | this.revokeAllCachedURLs(); 135 | return this.__pipectx.next(); 136 | }, 137 | 138 | revokeAllCachedURLs: function() { 139 | for (var url in this.cache.reverse) { 140 | this.llshandler.revokeAttachmentURL(url, {bypassUrlCache: true}); 141 | } 142 | 143 | this.cache.reverse = {}; 144 | this.cache.main = {}; 145 | } 146 | }; 147 | 148 | return { 149 | addTo: function(lls, options) { 150 | var cache = new URLCache(lls, options); 151 | lls.pipe.addFirst('URLCache', cache); 152 | return lls; 153 | } 154 | } 155 | })(); -------------------------------------------------------------------------------- /src/contrib/URLCache.js: -------------------------------------------------------------------------------- 1 | LargeLocalStorage.contrib.URLCache = (function() { 2 | var defaultOptions = { 3 | manageRevocation: true 4 | }; 5 | 6 | function defaults(options, defaultOptions) { 7 | for (var k in defaultOptions) { 8 | if (options[k] === undefined) 9 | options[k] = defaultOptions[k]; 10 | } 11 | 12 | return options; 13 | } 14 | 15 | function add(docKey, attachKey, url) { 16 | if (this.options.manageRevocation) 17 | expunge.call(this, docKey, attachKey, true); 18 | 19 | var mainCache = this.cache.main; 20 | var docCache = mainCache[docKey]; 21 | if (!docCache) { 22 | docCache = {}; 23 | mainCache[docKey] = docCache; 24 | } 25 | 26 | docCache[attachKey] = url; 27 | this.cache.reverse[url] = {docKey: docKey, attachKey: attachKey}; 28 | } 29 | 30 | function addAll(urlEntries) { 31 | urlEntries.forEach(function(entry) { 32 | add.call(this, entry.docKey, entry.attachKey, entry.url); 33 | }, this); 34 | } 35 | 36 | function expunge(docKey, attachKey, needsRevoke) { 37 | function delAndRevoke(attachKey) { 38 | var url = docCache[attachKey]; 39 | delete docCache[attachKey]; 40 | delete this.cache.reverse[url]; 41 | if (this.options.manageRevocation && needsRevoke) 42 | this.llshandler.revokeAttachmentURL(url, {bypassUrlCache: true}); 43 | } 44 | 45 | var docCache = this.cache.main[docKey]; 46 | if (docCache) { 47 | if (attachKey) { 48 | delAndRevoke.call(this, attachKey); 49 | } else { 50 | for (var attachKey in docCache) { 51 | delAndRevoke.call(this, attachKey); 52 | } 53 | delete this.cache.main[docKey]; 54 | } 55 | } 56 | } 57 | 58 | function expungeByUrl(url) { 59 | var keys = this.cache.reverse[url]; 60 | if (keys) { 61 | expunge.call(this, keys.docKey, keys.attachKey, false); 62 | } 63 | } 64 | 65 | 66 | function URLCache(llspipe, options) { 67 | options = options || {}; 68 | this.options = defaults(options, defaultOptions); 69 | this.llshandler = llspipe.pipe.getHandler('lls'); 70 | this.pending = {}; 71 | this.cache = { 72 | main: {}, 73 | reverse: {} 74 | }; 75 | } 76 | 77 | URLCache.prototype = { 78 | setAttachment: function(docKey, attachKey, blob) { 79 | expunge.call(this, docKey, attachKey); 80 | return this.__pipectx.next(docKey, attachKey, blob); 81 | }, 82 | 83 | rmAttachment: function(docKey, attachKey) { 84 | expunge.call(this, docKey, attachKey); 85 | return this.__pipectx.next(docKey, attachKey); 86 | }, 87 | 88 | rm: function(docKey) { 89 | expunge.call(this, docKey); 90 | return this.__pipectx.next(docKey); 91 | }, 92 | 93 | revokeAttachmentURL: function(url, options) { 94 | if (!options || !options.bypassUrlCache) 95 | expungeByUrl.call(this, url); 96 | 97 | return this.__pipectx.next(url, options); 98 | }, 99 | 100 | getAttachmentURL: function(docKey, attachKey) { 101 | var pendingKey = docKey + attachKey; 102 | var pending = this.pending[pendingKey]; 103 | if (pending) 104 | return pending; 105 | 106 | var promise = this.__pipectx.next(docKey, attachKey); 107 | var self = this; 108 | promise.then(function(url) { 109 | add.call(self, docKey, attachKey, url); 110 | delete self.pending[pendingKey]; 111 | }); 112 | 113 | this.pending[pendingKey] = promise; 114 | 115 | return promise; 116 | }, 117 | 118 | // TODO: pending between this and getAttachmentURL... 119 | // Execute this as an ls and then 120 | // a loop on getAttachmentURL instead??? 121 | // doing it the way mentiond above 122 | // will prevent us from leaking blobs. 123 | getAllAttachmentURLs: function(docKey) { 124 | var promise = this.__pipectx.next(docKey); 125 | var self = this; 126 | promise.then(function(urlEntries) { 127 | addAll.call(self, urlEntries); 128 | }); 129 | 130 | return promise; 131 | }, 132 | 133 | clear: function() { 134 | this.revokeAllCachedURLs(); 135 | return this.__pipectx.next(); 136 | }, 137 | 138 | revokeAllCachedURLs: function() { 139 | for (var url in this.cache.reverse) { 140 | this.llshandler.revokeAttachmentURL(url, {bypassUrlCache: true}); 141 | } 142 | 143 | this.cache.reverse = {}; 144 | this.cache.main = {}; 145 | } 146 | }; 147 | 148 | return { 149 | addTo: function(lls, options) { 150 | var cache = new URLCache(lls, options); 151 | lls.pipe.addFirst('URLCache', cache); 152 | return lls; 153 | } 154 | } 155 | })(); -------------------------------------------------------------------------------- /src/pipeline.js: -------------------------------------------------------------------------------- 1 | 2 | /** 3 | @author Matt Crinklaw-Vogt 4 | */ 5 | function PipeContext(handlers, nextMehod, end) { 6 | this._handlers = handlers; 7 | this._next = nextMehod; 8 | this._end = end; 9 | 10 | this._i = 0; 11 | } 12 | 13 | PipeContext.prototype = { 14 | next: function() { 15 | // var args = Array.prototype.slice.call(arguments, 0); 16 | // args.unshift(this); 17 | this.__pipectx = this; 18 | return this._next.apply(this, arguments); 19 | }, 20 | 21 | _nextHandler: function() { 22 | if (this._i >= this._handlers.length) return this._end; 23 | 24 | var handler = this._handlers[this._i].handler; 25 | this._i += 1; 26 | return handler; 27 | }, 28 | 29 | length: function() { 30 | return this._handlers.length; 31 | } 32 | }; 33 | 34 | function indexOfHandler(handlers, len, target) { 35 | for (var i = 0; i < len; ++i) { 36 | var handler = handlers[i]; 37 | if (handler.name === target || handler.handler === target) { 38 | return i; 39 | } 40 | } 41 | 42 | return -1; 43 | } 44 | 45 | function forward(ctx) { 46 | return ctx.next.apply(ctx, Array.prototype.slice.call(arguments, 1)); 47 | } 48 | 49 | function coerce(methodNames, handler) { 50 | methodNames.forEach(function(meth) { 51 | if (!handler[meth]) 52 | handler[meth] = forward; 53 | }); 54 | } 55 | 56 | var abstractPipeline = { 57 | addFirst: function(name, handler) { 58 | coerce(this._pipedMethodNames, handler); 59 | this._handlers.unshift({name: name, handler: handler}); 60 | }, 61 | 62 | addLast: function(name, handler) { 63 | coerce(this._pipedMethodNames, handler); 64 | this._handlers.push({name: name, handler: handler}); 65 | }, 66 | 67 | /** 68 | Add the handler with the given name after the 69 | handler specified by target. Target can be a handler 70 | name or a handler instance. 71 | */ 72 | addAfter: function(target, name, handler) { 73 | coerce(this._pipedMethodNames, handler); 74 | var handlers = this._handlers; 75 | var len = handlers.length; 76 | var i = indexOfHandler(handlers, len, target); 77 | 78 | if (i >= 0) { 79 | handlers.splice(i+1, 0, {name: name, handler: handler}); 80 | } 81 | }, 82 | 83 | /** 84 | Add the handler with the given name after the handler 85 | specified by target. Target can be a handler name or 86 | a handler instance. 87 | */ 88 | addBefore: function(target, name, handler) { 89 | coerce(this._pipedMethodNames, handler); 90 | var handlers = this._handlers; 91 | var len = handlers.length; 92 | var i = indexOfHandler(handlers, len, target); 93 | 94 | if (i >= 0) { 95 | handlers.splice(i, 0, {name: name, handler: handler}); 96 | } 97 | }, 98 | 99 | /** 100 | Replace the handler specified by target. 101 | */ 102 | replace: function(target, newName, handler) { 103 | coerce(this._pipedMethodNames, handler); 104 | var handlers = this._handlers; 105 | var len = handlers.length; 106 | var i = indexOfHandler(handlers, len, target); 107 | 108 | if (i >= 0) { 109 | handlers.splice(i, 1, {name: newName, handler: handler}); 110 | } 111 | }, 112 | 113 | removeFirst: function() { 114 | return this._handlers.shift(); 115 | }, 116 | 117 | removeLast: function() { 118 | return this._handlers.pop(); 119 | }, 120 | 121 | remove: function(target) { 122 | var handlers = this._handlers; 123 | var len = handlers.length; 124 | var i = indexOfHandler(handlers, len, target); 125 | 126 | if (i >= 0) 127 | handlers.splice(i, 1); 128 | }, 129 | 130 | getHandler: function(name) { 131 | var i = indexOfHandler(this._handlers, this._handlers.length, name); 132 | if (i >= 0) 133 | return this._handlers[i].handler; 134 | return null; 135 | } 136 | }; 137 | 138 | function createPipeline(pipedMethodNames) { 139 | var end = {}; 140 | var endStubFunc = function() { return end; }; 141 | var nextMethods = {}; 142 | 143 | function Pipeline(pipedMethodNames) { 144 | this.pipe = { 145 | _handlers: [], 146 | _contextCtor: PipeContext, 147 | _nextMethods: nextMethods, 148 | end: end, 149 | _pipedMethodNames: pipedMethodNames 150 | }; 151 | } 152 | 153 | var pipeline = new Pipeline(pipedMethodNames); 154 | for (var k in abstractPipeline) { 155 | pipeline.pipe[k] = abstractPipeline[k]; 156 | } 157 | 158 | pipedMethodNames.forEach(function(name) { 159 | end[name] = endStubFunc; 160 | 161 | nextMethods[name] = new Function( 162 | "var handler = this._nextHandler();" + 163 | "handler.__pipectx = this.__pipectx;" + 164 | "return handler." + name + ".apply(handler, arguments);"); 165 | 166 | pipeline[name] = new Function( 167 | "var ctx = new this.pipe._contextCtor(this.pipe._handlers, this.pipe._nextMethods." + name + ", this.pipe.end);" 168 | + "return ctx.next.apply(ctx, arguments);"); 169 | }); 170 | 171 | return pipeline; 172 | } 173 | 174 | createPipeline.isPipeline = function(obj) { 175 | return obj instanceof Pipeline; 176 | } -------------------------------------------------------------------------------- /test/lib/mocha/mocha.css: -------------------------------------------------------------------------------- 1 | @charset "utf-8"; 2 | 3 | body { 4 | margin:0; 5 | } 6 | 7 | #mocha { 8 | font: 20px/1.5 "Helvetica Neue", Helvetica, Arial, sans-serif; 9 | margin: 60px 50px; 10 | } 11 | 12 | #mocha ul, #mocha li { 13 | margin: 0; 14 | padding: 0; 15 | } 16 | 17 | #mocha ul { 18 | list-style: none; 19 | } 20 | 21 | #mocha h1, #mocha h2 { 22 | margin: 0; 23 | } 24 | 25 | #mocha h1 { 26 | margin-top: 15px; 27 | font-size: 1em; 28 | font-weight: 200; 29 | } 30 | 31 | #mocha h1 a { 32 | text-decoration: none; 33 | color: inherit; 34 | } 35 | 36 | #mocha h1 a:hover { 37 | text-decoration: underline; 38 | } 39 | 40 | #mocha .suite .suite h1 { 41 | margin-top: 0; 42 | font-size: .8em; 43 | } 44 | 45 | #mocha .hidden { 46 | display: none; 47 | } 48 | 49 | #mocha h2 { 50 | font-size: 12px; 51 | font-weight: normal; 52 | cursor: pointer; 53 | } 54 | 55 | #mocha .suite { 56 | margin-left: 15px; 57 | } 58 | 59 | #mocha .test { 60 | margin-left: 15px; 61 | overflow: hidden; 62 | } 63 | 64 | #mocha .test.pending:hover h2::after { 65 | content: '(pending)'; 66 | font-family: arial, sans-serif; 67 | } 68 | 69 | #mocha .test.pass.medium .duration { 70 | background: #C09853; 71 | } 72 | 73 | #mocha .test.pass.slow .duration { 74 | background: #B94A48; 75 | } 76 | 77 | #mocha .test.pass::before { 78 | content: '✓'; 79 | font-size: 12px; 80 | display: block; 81 | float: left; 82 | margin-right: 5px; 83 | color: #00d6b2; 84 | } 85 | 86 | #mocha .test.pass .duration { 87 | font-size: 9px; 88 | margin-left: 5px; 89 | padding: 2px 5px; 90 | color: white; 91 | -webkit-box-shadow: inset 0 1px 1px rgba(0,0,0,.2); 92 | -moz-box-shadow: inset 0 1px 1px rgba(0,0,0,.2); 93 | box-shadow: inset 0 1px 1px rgba(0,0,0,.2); 94 | -webkit-border-radius: 5px; 95 | -moz-border-radius: 5px; 96 | -ms-border-radius: 5px; 97 | -o-border-radius: 5px; 98 | border-radius: 5px; 99 | } 100 | 101 | #mocha .test.pass.fast .duration { 102 | display: none; 103 | } 104 | 105 | #mocha .test.pending { 106 | color: #0b97c4; 107 | } 108 | 109 | #mocha .test.pending::before { 110 | content: '◦'; 111 | color: #0b97c4; 112 | } 113 | 114 | #mocha .test.fail { 115 | color: #c00; 116 | } 117 | 118 | #mocha .test.fail pre { 119 | color: black; 120 | } 121 | 122 | #mocha .test.fail::before { 123 | content: '✖'; 124 | font-size: 12px; 125 | display: block; 126 | float: left; 127 | margin-right: 5px; 128 | color: #c00; 129 | } 130 | 131 | #mocha .test pre.error { 132 | color: #c00; 133 | max-height: 300px; 134 | overflow: auto; 135 | } 136 | 137 | #mocha .test pre { 138 | display: block; 139 | float: left; 140 | clear: left; 141 | font: 12px/1.5 monaco, monospace; 142 | margin: 5px; 143 | padding: 15px; 144 | border: 1px solid #eee; 145 | border-bottom-color: #ddd; 146 | -webkit-border-radius: 3px; 147 | -webkit-box-shadow: 0 1px 3px #eee; 148 | -moz-border-radius: 3px; 149 | -moz-box-shadow: 0 1px 3px #eee; 150 | border-radius: 3px; 151 | } 152 | 153 | #mocha .test h2 { 154 | position: relative; 155 | } 156 | 157 | #mocha .test a.replay { 158 | position: absolute; 159 | top: 3px; 160 | right: 0; 161 | text-decoration: none; 162 | vertical-align: middle; 163 | display: block; 164 | width: 15px; 165 | height: 15px; 166 | line-height: 15px; 167 | text-align: center; 168 | background: #eee; 169 | font-size: 15px; 170 | -moz-border-radius: 15px; 171 | border-radius: 15px; 172 | -webkit-transition: opacity 200ms; 173 | -moz-transition: opacity 200ms; 174 | transition: opacity 200ms; 175 | opacity: 0.3; 176 | color: #888; 177 | } 178 | 179 | #mocha .test:hover a.replay { 180 | opacity: 1; 181 | } 182 | 183 | #mocha-report.pass .test.fail { 184 | display: none; 185 | } 186 | 187 | #mocha-report.fail .test.pass { 188 | display: none; 189 | } 190 | 191 | #mocha-report.pending .test.pass, 192 | #mocha-report.pending .test.fail { 193 | display: none; 194 | } 195 | #mocha-report.pending .test.pass.pending { 196 | display: block; 197 | } 198 | 199 | #mocha-error { 200 | color: #c00; 201 | font-size: 1.5em; 202 | font-weight: 100; 203 | letter-spacing: 1px; 204 | } 205 | 206 | #mocha-stats { 207 | position: fixed; 208 | top: 15px; 209 | right: 10px; 210 | font-size: 12px; 211 | margin: 0; 212 | color: #888; 213 | z-index: 1; 214 | } 215 | 216 | #mocha-stats .progress { 217 | float: right; 218 | padding-top: 0; 219 | } 220 | 221 | #mocha-stats em { 222 | color: black; 223 | } 224 | 225 | #mocha-stats a { 226 | text-decoration: none; 227 | color: inherit; 228 | } 229 | 230 | #mocha-stats a:hover { 231 | border-bottom: 1px solid #eee; 232 | } 233 | 234 | #mocha-stats li { 235 | display: inline-block; 236 | margin: 0 5px; 237 | list-style: none; 238 | padding-top: 11px; 239 | } 240 | 241 | #mocha-stats canvas { 242 | width: 40px; 243 | height: 40px; 244 | } 245 | 246 | #mocha code .comment { color: #ddd } 247 | #mocha code .init { color: #2F6FAD } 248 | #mocha code .string { color: #5890AD } 249 | #mocha code .keyword { color: #8A6343 } 250 | #mocha code .number { color: #2F6FAD } 251 | 252 | @media screen and (max-device-width: 480px) { 253 | #mocha { 254 | margin: 60px 0px; 255 | } 256 | 257 | #mocha #stats { 258 | position: absolute; 259 | } 260 | } -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | LargeLocalStorage 2 | ================= 3 | 4 | 5 | **Problem:** You need a large key-value store in the browser. 6 | 7 | To make things worse: 8 | * DOMStorage only gives you 5mb 9 | * Chrome doesn't let you store blobs in IndexedDB 10 | * Safari doesn't support IndexedDB, 11 | * IE and Firefox both support IndexedDB but not the FilesystemAPI. 12 | 13 | `LargeLocalStorage` bridges all of that to give you a large capacity (up to several GB when authorized by the user) key-value store in the browser 14 | (IE 10, Chrome, Safari 6+, Firefox, Opera). 15 | 16 | * [docs](http://tantaman.github.io/LargeLocalStorage/doc/classes/LargeLocalStorage.html) 17 | * [tests](http://tantaman.github.io/LargeLocalStorage/test/) 18 | * [demo app](http://tantaman.github.io/LargeLocalStorage/examples/album/) 19 | 20 | ## Basic Rundown / Examples 21 | 22 | ### Creating a database 23 | 24 | ```javascript 25 | // Specify desired capacity in bytes 26 | var desiredCapacity = 125 * 1024 * 1024; 27 | 28 | // Create a 125MB key-value store 29 | var storage = new LargeLocalStorage({size: desiredCapacity, name: 'myDb'}); 30 | 31 | // Await initialization of the storage area 32 | storage.initialized.then(function(grantedCapacity) { 33 | // Check to see how much space the user authorized us to actually use. 34 | // Some browsers don't indicate how much space was granted in which case 35 | // grantedCapacity will be 1. 36 | if (grantedCapacity != -1 && grantedCapacity != desiredCapacity) { 37 | } 38 | }); 39 | ``` 40 | 41 | ### Setting data 42 | 43 | ```javascript 44 | // You can set the contents of "documents" which are identified by a key. 45 | // Documents can only contains strings for their values but binary 46 | // data can be added as attachments. 47 | // All operations are asynchronous and return Q promises 48 | storage.setContents('docKey', "the contents...").then(function() { 49 | alert('doc created/updated'); 50 | }); 51 | 52 | // Attachments can be added to documents. 53 | // Attachments are Blobs or any subclass of Blob (e.g, File). 54 | // Attachments can be added whether or not a corresponding document exists. 55 | // setAttachment returns a promise so you know when the set has completed. 56 | storage.setAttachment('myDoc', 'titleImage', blob).then(function() { 57 | alert('finished setting the titleImage attachment'); 58 | }); 59 | ``` 60 | 61 | ### Retrieving Data 62 | 63 | ```javascript 64 | // get the contents of a document 65 | storage.getContents('myDoc').then(function(content) { 66 | }); 67 | 68 | // Call getAttachment with the docKey and attachmentKey 69 | storage.getAttachment('myDoc', 'titleImage').then(function(titleImage) { 70 | // Create an image element with the retrieved attachment 71 | // (or video or sound or whatever you decide to attach and use) 72 | var img = new Image(); 73 | img.src = URL.createObjectURL(titleImage); 74 | document.body.appendChild(img); 75 | URL.revokeObjectURL(titleImage); 76 | }); 77 | 78 | 79 | // If you just need a URL to your attachment you can get 80 | // the attachment URL instead of the attachment itself 81 | storge.getAttachmentURL('somePreviouslySavedDoc', 'someAttachment').then(function(url) { 82 | // do something with the attachment URL 83 | // ... 84 | 85 | // revoke the URL 86 | storage.revokeAttachmentURL(url); 87 | }); 88 | ``` 89 | 90 | ### Listing 91 | ```javascript 92 | // You can do an ls to get all of the keys in your data store 93 | storage.ls().then(function(listing) { 94 | // listing is a list of all of the document keys 95 | alert(listing); 96 | }); 97 | 98 | // Or get a listing of a document's attachments 99 | storage.ls('somePreviouslySavedDoc').then(function(listing) { 100 | // listing is a list of all attachments belonging to `somePreviouslySavedDoc` 101 | alert(listing); 102 | }); 103 | ``` 104 | 105 | ### Removing 106 | ```javascript 107 | // you can remove a document with rm 108 | // removing a document also removes all of that document's 109 | // attachments. 110 | storage.rm('somePreviouslySavedDoc'); 111 | 112 | // you can also rm an attachment 113 | storage.rmAttachment('someOtherDocKey', 'attachmentKey'); 114 | 115 | // removals return promises as well so you know when the removal completes (or fails). 116 | storage.rm('docKey').then(function() { 117 | alert('Removed!'); 118 | }, function(err) { 119 | console.error('Failed removal'); 120 | console.error(err); 121 | }); 122 | 123 | // clear the entire database 124 | storage.clear(); 125 | ``` 126 | 127 | More: 128 | * Read the [docs](http://tantaman.github.io/LargeLocalStorage/doc/classes/LargeLocalStorage.html) 129 | * Run the [tests](http://tantaman.github.io/LargeLocalStorage/test/) 130 | * View the [demo app](http://tantaman.github.io/LargeLocalStorage/examples/album/) 131 | 132 | ##Including 133 | 134 | Include it on your page with a script tag: 135 | 136 | ``` 137 | 138 | ``` 139 | 140 | Or load it as an amd module: 141 | 142 | ``` 143 | define(['components/lls/dist/LargeLocalStorage'], function(lls) { 144 | var storage = new lls({size: 100 * 1024 * 1024}); 145 | }); 146 | ``` 147 | 148 | LLS depends on [Q](https://github.com/kriskowal/q) so you'll have to make sure you have that dependency. 149 | 150 | ##Getting 151 | downlad it directly 152 | 153 | * (dev) https://raw.github.com/tantaman/LargeLocalStorage/master/dist/LargeLocalStorage.js 154 | * (min) https://raw.github.com/tantaman/LargeLocalStorage/master/dist/LargeLocalStorage.min.js 155 | 156 | Or `bower install lls` 157 | -------------------------------------------------------------------------------- /src/impls/WebSQLProvider.js: -------------------------------------------------------------------------------- 1 | var openDb = window.openDatabase; 2 | var WebSQLProvider = (function(Q) { 3 | var URL = window.URL || window.webkitURL; 4 | var convertToBase64 = utils.convertToBase64; 5 | var dataURLToBlob = utils.dataURLToBlob; 6 | 7 | function WSQL(db) { 8 | this._db = db; 9 | this.type = 'WebSQL'; 10 | } 11 | 12 | WSQL.prototype = { 13 | getContents: function(docKey, options) { 14 | var deferred = Q.defer(); 15 | this._db.transaction(function(tx) { 16 | tx.executeSql('SELECT value FROM files WHERE fname = ?', [docKey], 17 | function(tx, res) { 18 | if (res.rows.length == 0) { 19 | deferred.resolve(undefined); 20 | } else { 21 | var data = res.rows.item(0).value; 22 | if (options && options.json) 23 | data = JSON.parse(data); 24 | deferred.resolve(data); 25 | } 26 | }); 27 | }, function(err) { 28 | consol.log(err); 29 | deferred.reject(err); 30 | }); 31 | 32 | return deferred.promise; 33 | }, 34 | 35 | setContents: function(docKey, data, options) { 36 | var deferred = Q.defer(); 37 | if (options && options.json) 38 | data = JSON.stringify(data); 39 | 40 | this._db.transaction(function(tx) { 41 | tx.executeSql( 42 | 'INSERT OR REPLACE INTO files (fname, value) VALUES(?, ?)', [docKey, data]); 43 | }, function(err) { 44 | console.log(err); 45 | deferred.reject(err); 46 | }, function() { 47 | deferred.resolve(); 48 | }); 49 | 50 | return deferred.promise; 51 | }, 52 | 53 | rm: function(docKey) { 54 | var deferred = Q.defer(); 55 | 56 | this._db.transaction(function(tx) { 57 | tx.executeSql('DELETE FROM files WHERE fname = ?', [docKey]); 58 | tx.executeSql('DELETE FROM attachments WHERE fname = ?', [docKey]); 59 | }, function(err) { 60 | console.log(err); 61 | deferred.reject(err); 62 | }, function() { 63 | deferred.resolve(); 64 | }); 65 | 66 | return deferred.promise; 67 | }, 68 | 69 | getAttachment: function(fname, akey) { 70 | var deferred = Q.defer(); 71 | 72 | this._db.transaction(function(tx){ 73 | tx.executeSql('SELECT value FROM attachments WHERE fname = ? AND akey = ?', 74 | [fname, akey], 75 | function(tx, res) { 76 | if (res.rows.length == 0) { 77 | deferred.resolve(undefined); 78 | } else { 79 | deferred.resolve(dataURLToBlob(res.rows.item(0).value)); 80 | } 81 | }); 82 | }, function(err) { 83 | deferred.reject(err); 84 | }); 85 | 86 | return deferred.promise; 87 | }, 88 | 89 | getAttachmentURL: function(docKey, attachKey) { 90 | var deferred = Q.defer(); 91 | this.getAttachment(docKey, attachKey).then(function(blob) { 92 | deferred.resolve(URL.createObjectURL(blob)); 93 | }, function() { 94 | deferred.reject(); 95 | }); 96 | 97 | return deferred.promise; 98 | }, 99 | 100 | ls: function(docKey) { 101 | var deferred = Q.defer(); 102 | 103 | var select; 104 | var field; 105 | if (!docKey) { 106 | select = 'SELECT fname FROM files'; 107 | field = 'fname'; 108 | } else { 109 | select = 'SELECT akey FROM attachments WHERE fname = ?'; 110 | field = 'akey'; 111 | } 112 | 113 | this._db.transaction(function(tx) { 114 | tx.executeSql(select, docKey ? [docKey] : [], 115 | function(tx, res) { 116 | var listing = []; 117 | for (var i = 0; i < res.rows.length; ++i) { 118 | listing.push(res.rows.item(i)[field]); 119 | } 120 | 121 | deferred.resolve(listing); 122 | }, function(err) { 123 | deferred.reject(err); 124 | }); 125 | }); 126 | 127 | return deferred.promise; 128 | }, 129 | 130 | clear: function() { 131 | var deffered1 = Q.defer(); 132 | var deffered2 = Q.defer(); 133 | 134 | this._db.transaction(function(tx) { 135 | tx.executeSql('DELETE FROM files', function() { 136 | deffered1.resolve(); 137 | }); 138 | tx.executeSql('DELETE FROM attachments', function() { 139 | deffered2.resolve(); 140 | }); 141 | }, function(err) { 142 | deffered1.reject(err); 143 | deffered2.reject(err); 144 | }); 145 | 146 | return Q.all([deffered1, deffered2]); 147 | }, 148 | 149 | getAllAttachments: function(fname) { 150 | var deferred = Q.defer(); 151 | 152 | this._db.transaction(function(tx) { 153 | tx.executeSql('SELECT value, akey FROM attachments WHERE fname = ?', 154 | [fname], 155 | function(tx, res) { 156 | // TODO: ship this work off to a webworker 157 | // since there could be many of these conversions? 158 | var result = []; 159 | for (var i = 0; i < res.rows.length; ++i) { 160 | var item = res.rows.item(i); 161 | result.push({ 162 | docKey: fname, 163 | attachKey: item.akey, 164 | data: dataURLToBlob(item.value) 165 | }); 166 | } 167 | 168 | deferred.resolve(result); 169 | }); 170 | }, function(err) { 171 | deferred.reject(err); 172 | }); 173 | 174 | return deferred.promise; 175 | }, 176 | 177 | getAllAttachmentURLs: function(fname) { 178 | var deferred = Q.defer(); 179 | this.getAllAttachments(fname).then(function(attachments) { 180 | var urls = attachments.map(function(a) { 181 | a.url = URL.createObjectURL(a.data); 182 | delete a.data; 183 | return a; 184 | }); 185 | 186 | deferred.resolve(urls); 187 | }, function(e) { 188 | deferred.reject(e); 189 | }); 190 | 191 | return deferred.promise; 192 | }, 193 | 194 | revokeAttachmentURL: function(url) { 195 | URL.revokeObjectURL(url); 196 | }, 197 | 198 | setAttachment: function(fname, akey, data) { 199 | var deferred = Q.defer(); 200 | 201 | var self = this; 202 | convertToBase64(data, function(data) { 203 | self._db.transaction(function(tx) { 204 | tx.executeSql( 205 | 'INSERT OR REPLACE INTO attachments (fname, akey, value) VALUES(?, ?, ?)', 206 | [fname, akey, data]); 207 | }, function(err) { 208 | deferred.reject(err); 209 | }, function() { 210 | deferred.resolve(); 211 | }); 212 | }); 213 | 214 | return deferred.promise; 215 | }, 216 | 217 | rmAttachment: function(fname, akey) { 218 | var deferred = Q.defer(); 219 | this._db.transaction(function(tx) { 220 | tx.executeSql('DELETE FROM attachments WHERE fname = ? AND akey = ?', 221 | [fname, akey]); 222 | }, function(err) { 223 | deferred.reject(err); 224 | }, function() { 225 | deferred.resolve(); 226 | }); 227 | 228 | return deferred.promise; 229 | } 230 | }; 231 | 232 | return { 233 | init: function(config) { 234 | var deferred = Q.defer(); 235 | if (!openDb) { 236 | deferred.reject("No WebSQL"); 237 | return deferred.promise; 238 | } 239 | 240 | var db = openDb(config.name, '1.0', 'large local storage', config.size); 241 | 242 | db.transaction(function(tx) { 243 | tx.executeSql('CREATE TABLE IF NOT EXISTS files (fname unique, value)'); 244 | tx.executeSql('CREATE TABLE IF NOT EXISTS attachments (fname, akey, value)'); 245 | tx.executeSql('CREATE INDEX IF NOT EXISTS fname_index ON attachments (fname)'); 246 | tx.executeSql('CREATE INDEX IF NOT EXISTS akey_index ON attachments (akey)'); 247 | tx.executeSql('CREATE UNIQUE INDEX IF NOT EXISTS uniq_attach ON attachments (fname, akey)') 248 | }, function(err) { 249 | deferred.reject(err); 250 | }, function() { 251 | deferred.resolve(new WSQL(db)); 252 | }); 253 | 254 | return deferred.promise; 255 | }, 256 | 257 | isAvailable: function() { 258 | return openDb != null; 259 | } 260 | } 261 | })(Q); -------------------------------------------------------------------------------- /src/impls/IndexedDBProvider.js: -------------------------------------------------------------------------------- 1 | var indexedDB = window.indexedDB || window.webkitIndexedDB || window.mozIndexedDB || window.OIndexedDB || window.msIndexedDB; 2 | var IDBTransaction = window.IDBTransaction || window.webkitIDBTransaction || window.OIDBTransaction || window.msIDBTransaction; 3 | var IndexedDBProvider = (function(Q) { 4 | var URL = window.URL || window.webkitURL; 5 | 6 | var convertToBase64 = utils.convertToBase64; 7 | var dataURLToBlob = utils.dataURLToBlob; 8 | 9 | function IDB(db) { 10 | this._db = db; 11 | this.type = 'IndexedDB'; 12 | 13 | var transaction = this._db.transaction(['attachments'], 'readwrite'); 14 | this._supportsBlobs = true; 15 | try { 16 | transaction.objectStore('attachments') 17 | .put(Blob(["sdf"], {type: "text/plain"}), "featurecheck"); 18 | } catch (e) { 19 | this._supportsBlobs = false; 20 | } 21 | } 22 | 23 | // TODO: normalize returns and errors. 24 | IDB.prototype = { 25 | getContents: function(docKey) { 26 | var deferred = Q.defer(); 27 | var transaction = this._db.transaction(['files'], 'readonly'); 28 | 29 | var get = transaction.objectStore('files').get(docKey); 30 | get.onsuccess = function(e) { 31 | deferred.resolve(e.target.result); 32 | }; 33 | 34 | get.onerror = function(e) { 35 | deferred.reject(e); 36 | }; 37 | 38 | return deferred.promise; 39 | }, 40 | 41 | setContents: function(docKey, data) { 42 | var deferred = Q.defer(); 43 | var transaction = this._db.transaction(['files'], 'readwrite'); 44 | 45 | var put = transaction.objectStore('files').put(data, docKey); 46 | put.onsuccess = function(e) { 47 | deferred.resolve(e); 48 | }; 49 | 50 | put.onerror = function(e) { 51 | deferred.reject(e); 52 | }; 53 | 54 | return deferred.promise; 55 | }, 56 | 57 | rm: function(docKey) { 58 | var deferred = Q.defer(); 59 | var finalDeferred = Q.defer(); 60 | 61 | var transaction = this._db.transaction(['files', 'attachments'], 'readwrite'); 62 | 63 | var del = transaction.objectStore('files').delete(docKey); 64 | 65 | del.onsuccess = function(e) { 66 | deferred.promise.then(function() { 67 | finalDeferred.resolve(); 68 | }); 69 | }; 70 | 71 | del.onerror = function(e) { 72 | deferred.promise.catch(function() { 73 | finalDeferred.reject(e); 74 | }); 75 | }; 76 | 77 | var attachmentsStore = transaction.objectStore('attachments'); 78 | var index = attachmentsStore.index('fname'); 79 | var cursor = index.openCursor(IDBKeyRange.only(docKey)); 80 | cursor.onsuccess = function(e) { 81 | var cursor = e.target.result; 82 | if (cursor) { 83 | cursor.delete(); 84 | cursor.continue(); 85 | } else { 86 | deferred.resolve(); 87 | } 88 | }; 89 | 90 | cursor.onerror = function(e) { 91 | deferred.reject(e); 92 | } 93 | 94 | return finalDeferred.promise; 95 | }, 96 | 97 | getAttachment: function(docKey, attachKey) { 98 | var deferred = Q.defer(); 99 | 100 | var transaction = this._db.transaction(['attachments'], 'readonly'); 101 | var get = transaction.objectStore('attachments').get(docKey + '/' + attachKey); 102 | 103 | var self = this; 104 | get.onsuccess = function(e) { 105 | if (!e.target.result) { 106 | deferred.resolve(undefined); 107 | return; 108 | } 109 | 110 | var data = e.target.result.data; 111 | if (!self._supportsBlobs) { 112 | data = dataURLToBlob(data); 113 | } 114 | deferred.resolve(data); 115 | }; 116 | 117 | get.onerror = function(e) { 118 | deferred.reject(e); 119 | }; 120 | 121 | return deferred.promise; 122 | }, 123 | 124 | ls: function(docKey) { 125 | var deferred = Q.defer(); 126 | 127 | if (!docKey) { 128 | // list docs 129 | var store = 'files'; 130 | } else { 131 | // list attachments 132 | var store = 'attachments'; 133 | } 134 | 135 | var transaction = this._db.transaction([store], 'readonly'); 136 | var cursor = transaction.objectStore(store).openCursor(); 137 | var listing = []; 138 | 139 | cursor.onsuccess = function(e) { 140 | var cursor = e.target.result; 141 | if (cursor) { 142 | listing.push(!docKey ? cursor.key : cursor.key.split('/')[1]); 143 | cursor.continue(); 144 | } else { 145 | deferred.resolve(listing); 146 | } 147 | }; 148 | 149 | cursor.onerror = function(e) { 150 | deferred.reject(e); 151 | }; 152 | 153 | return deferred.promise; 154 | }, 155 | 156 | clear: function() { 157 | var deferred = Q.defer(); 158 | var finalDeferred = Q.defer(); 159 | 160 | var t = this._db.transaction(['attachments', 'files'], 'readwrite'); 161 | 162 | 163 | var req1 = t.objectStore('attachments').clear(); 164 | var req2 = t.objectStore('files').clear(); 165 | 166 | req1.onsuccess = function() { 167 | deferred.promise.then(finalDeferred.resolve); 168 | }; 169 | 170 | req2.onsuccess = function() { 171 | deferred.resolve(); 172 | }; 173 | 174 | req1.onerror = function(err) { 175 | finalDeferred.reject(err); 176 | }; 177 | 178 | req2.onerror = function(err) { 179 | finalDeferred.reject(err); 180 | }; 181 | 182 | return finalDeferred.promise; 183 | }, 184 | 185 | getAllAttachments: function(docKey) { 186 | var deferred = Q.defer(); 187 | var self = this; 188 | 189 | var transaction = this._db.transaction(['attachments'], 'readonly'); 190 | var index = transaction.objectStore('attachments').index('fname'); 191 | 192 | var cursor = index.openCursor(IDBKeyRange.only(docKey)); 193 | var values = []; 194 | cursor.onsuccess = function(e) { 195 | var cursor = e.target.result; 196 | if (cursor) { 197 | var data; 198 | if (!self._supportsBlobs) { 199 | data = dataURLToBlob(cursor.value.data) 200 | } else { 201 | data = cursor.value.data; 202 | } 203 | values.push({ 204 | data: data, 205 | docKey: docKey, 206 | attachKey: cursor.primaryKey.split('/')[1] // TODO 207 | }); 208 | cursor.continue(); 209 | } else { 210 | deferred.resolve(values); 211 | } 212 | }; 213 | 214 | cursor.onerror = function(e) { 215 | deferred.reject(e); 216 | }; 217 | 218 | return deferred.promise; 219 | }, 220 | 221 | getAllAttachmentURLs: function(docKey) { 222 | var deferred = Q.defer(); 223 | this.getAllAttachments(docKey).then(function(attachments) { 224 | var urls = attachments.map(function(a) { 225 | a.url = URL.createObjectURL(a.data); 226 | delete a.data; 227 | return a; 228 | }); 229 | 230 | deferred.resolve(urls); 231 | }, function(e) { 232 | deferred.reject(e); 233 | }); 234 | 235 | return deferred.promise; 236 | }, 237 | 238 | getAttachmentURL: function(docKey, attachKey) { 239 | var deferred = Q.defer(); 240 | this.getAttachment(docKey, attachKey).then(function(attachment) { 241 | deferred.resolve(URL.createObjectURL(attachment)); 242 | }, function(e) { 243 | deferred.reject(e); 244 | }); 245 | 246 | return deferred.promise; 247 | }, 248 | 249 | revokeAttachmentURL: function(url) { 250 | URL.revokeObjectURL(url); 251 | }, 252 | 253 | setAttachment: function(docKey, attachKey, data) { 254 | var deferred = Q.defer(); 255 | 256 | if (data instanceof Blob && !this._supportsBlobs) { 257 | var self = this; 258 | convertToBase64(data, function(data) { 259 | continuation.call(self, data); 260 | }); 261 | } else { 262 | continuation.call(this, data); 263 | } 264 | 265 | function continuation(data) { 266 | var obj = { 267 | path: docKey + '/' + attachKey, 268 | fname: docKey, 269 | data: data 270 | }; 271 | var transaction = this._db.transaction(['attachments'], 'readwrite'); 272 | var put = transaction.objectStore('attachments').put(obj); 273 | 274 | put.onsuccess = function(e) { 275 | deferred.resolve(e); 276 | }; 277 | 278 | put.onerror = function(e) { 279 | deferred.reject(e); 280 | }; 281 | } 282 | 283 | return deferred.promise; 284 | }, 285 | 286 | rmAttachment: function(docKey, attachKey) { 287 | var deferred = Q.defer(); 288 | var transaction = this._db.transaction(['attachments'], 'readwrite'); 289 | var del = transaction.objectStore('attachments').delete(docKey + '/' + attachKey); 290 | 291 | del.onsuccess = function(e) { 292 | deferred.resolve(e); 293 | }; 294 | 295 | del.onerror = function(e) { 296 | deferred.reject(e); 297 | }; 298 | 299 | return deferred.promise; 300 | } 301 | }; 302 | 303 | return { 304 | init: function(config) { 305 | var deferred = Q.defer(); 306 | var dbVersion = 2; 307 | 308 | if (!indexedDB || !IDBTransaction) { 309 | deferred.reject("No IndexedDB"); 310 | return deferred.promise; 311 | } 312 | 313 | var request = indexedDB.open(config.name, dbVersion); 314 | 315 | function createObjectStore(db) { 316 | db.createObjectStore("files"); 317 | var attachStore = db.createObjectStore("attachments", {keyPath: 'path'}); 318 | attachStore.createIndex('fname', 'fname', {unique: false}) 319 | } 320 | 321 | // TODO: normalize errors 322 | request.onerror = function (event) { 323 | deferred.reject(event); 324 | }; 325 | 326 | request.onsuccess = function (event) { 327 | var db = request.result; 328 | 329 | db.onerror = function (event) { 330 | console.log(event); 331 | }; 332 | 333 | // Chrome workaround 334 | if (db.setVersion) { 335 | if (db.version != dbVersion) { 336 | var setVersion = db.setVersion(dbVersion); 337 | setVersion.onsuccess = function () { 338 | createObjectStore(db); 339 | deferred.resolve(); 340 | }; 341 | } 342 | else { 343 | deferred.resolve(new IDB(db)); 344 | } 345 | } else { 346 | deferred.resolve(new IDB(db)); 347 | } 348 | } 349 | 350 | request.onupgradeneeded = function (event) { 351 | createObjectStore(event.target.result); 352 | }; 353 | 354 | return deferred.promise; 355 | }, 356 | 357 | isAvailable: function() { 358 | return indexedDB != null && IDBTransaction != null; 359 | } 360 | } 361 | })(Q); -------------------------------------------------------------------------------- /test/spec/LargeLocalStorageTest.js: -------------------------------------------------------------------------------- 1 | (function(lls) { 2 | Q.longStackSupport = true; 3 | Q.onerror = function(err) { 4 | console.log(err); 5 | throw err; 6 | }; 7 | 8 | var storage = new lls({ 9 | size: 10 * 1024 * 1024, 10 | name: 'lls-test' 11 | // forceProvider: 'WebSQL' // force a desired provider. 12 | }); 13 | 14 | // for debug 15 | // window.storage = storage; 16 | 17 | function getAttachment(a, cb) { 18 | var xhr = new XMLHttpRequest(), 19 | blob; 20 | 21 | xhr.open("GET", a, true); 22 | var is_safari = navigator.userAgent.indexOf("Safari") > -1; 23 | if (is_safari) { 24 | xhr.responseType = "arraybuffer"; 25 | } else { 26 | xhr.responseType = "blob"; 27 | } 28 | 29 | xhr.addEventListener("load", function () { 30 | if (xhr.status === 200) { 31 | if (is_safari) { 32 | blob = new Blob([xhr.response], {type: 'image/jpeg'}); 33 | } else { 34 | blob = xhr.response; 35 | } 36 | cb(blob); 37 | } 38 | }, false); 39 | xhr.send(); 40 | } 41 | 42 | describe('LargeLocalStorage', function() { 43 | it('Allows string contents to be set and read', function(done) { 44 | storage.setContents("testFile", "contents").then(function() { 45 | return storage.getContents("testFile"); 46 | }).then(function(contents) { 47 | expect(contents).to.equal("contents"); 48 | }).done(done); 49 | }); 50 | 51 | it('Allows js objects to be set and read', function(done) { 52 | var jsondoc = { 53 | a: 1, 54 | b: 2, 55 | c: {a: true} 56 | }; 57 | storage.setContents("testfile2", jsondoc, {json:true}).then(function() { 58 | return storage.getContents("testfile2", {json:true}); 59 | }).then(function(contents) { 60 | expect(jsondoc).to.eql(contents); 61 | }).done(done); 62 | }); 63 | 64 | it('Allows items to be deleted', function(done) { 65 | storage.setContents("testfile3", "contents").then(function() { 66 | return storage.rm("testfile3"); 67 | }).then(function() { 68 | return storage.getContents("testfile3"); 69 | }).then(function(contents) { 70 | expect(contents).to.equal(undefined); 71 | }).done(done); 72 | }); 73 | 74 | 75 | it('Allows attachments to be written, read', function(done) { 76 | getAttachment("elephant.jpg", function(blob) { 77 | storage.setContents("testfile4", "file...").then(function() { 78 | return storage.setAttachment("testfile4", "ele", blob); 79 | }).then(function() { 80 | return storage.getAttachment("testfile4", "ele"); 81 | }).then(function(attach) { 82 | expect(attach instanceof Blob).to.equal(true); 83 | }).done(done); 84 | }); 85 | }); 86 | 87 | 88 | // Apparently these tests are being run sequentially... 89 | // so taking advantage of that. 90 | it('Allows us to get attachments as urls', function(done) { 91 | storage.getAttachmentURL("testfile4", "ele").then(function(url) { 92 | // urls are pretty opaque since they could be from 93 | // filesystem api, indexeddb, or websql 94 | // meaning there isn't much we can do to verify them 95 | // besides ensure that they are strings. 96 | expect(typeof url === 'string').to.equal(true); 97 | $(document.body).append('