|
1 | 1 | (function () { |
2 | | - |
3 | 2 | // Basil |
4 | 3 | var Basil = function (options) { |
5 | | - return new Basil.Storage().init(options); |
| 4 | + return Basil.utils.extend(Basil.plugins, new Basil.Storage().init(options)); |
6 | 5 | }; |
7 | 6 |
|
8 | 7 | // Version |
9 | | - Basil.version = '0.3.2'; |
| 8 | + Basil.version = '0.3.3'; |
10 | 9 |
|
11 | 10 | // Utils |
12 | 11 | Basil.utils = { |
|
18 | 17 | destination[property] = arguments[i][property]; |
19 | 18 | } |
20 | 19 | return destination; |
| 20 | + }, |
| 21 | + registerPlugin: function (methods) { |
| 22 | + Basil.plugins = this.extend(methods, Basil.plugins); |
21 | 23 | } |
22 | 24 | }; |
23 | 25 |
|
| 26 | + Basil.plugins = {}; |
| 27 | + |
24 | 28 | // Options |
25 | 29 | Basil.options = Basil.utils.extend({ |
26 | 30 | namespace: 'b45i1', |
|
52 | 56 | } |
53 | 57 | return key; |
54 | 58 | }, |
| 59 | + _toKeyName = function (namespace, name) { |
| 60 | + return name.replace(namespace + ':', ''); |
| 61 | + }, |
55 | 62 | _toStoredValue = function (value) { |
56 | 63 | return JSON.stringify(value); |
57 | 64 | }, |
|
83 | 90 | this.engine.removeItem(name); |
84 | 91 | }, |
85 | 92 | reset: function (namespace) { |
86 | | - for (var key, i = 0; i < this.engine.length; i++) { |
| 93 | + for (var i = 0, key; i < this.engine.length; i++) { |
87 | 94 | key = this.engine.key(i); |
88 | 95 | if (key.indexOf(namespace) === 0) { |
89 | 96 | this.remove(key); |
90 | 97 | i--; |
91 | 98 | } |
92 | 99 | } |
| 100 | + }, |
| 101 | + keys: function (namespace) { |
| 102 | + var keys = []; |
| 103 | + for (var i = 0, key; i < this.engine.length; i++) { |
| 104 | + key = this.engine.key(i); |
| 105 | + if (key.indexOf(namespace) === 0) |
| 106 | + keys.push(_toKeyName(namespace, key)); |
| 107 | + } |
| 108 | + return keys; |
93 | 109 | } |
94 | 110 | }; |
95 | 111 |
|
|
120 | 136 | if (key.indexOf(namespace) === 0) |
121 | 137 | this.remove(key); |
122 | 138 | } |
| 139 | + }, |
| 140 | + keys: function (namespace) { |
| 141 | + var keys = []; |
| 142 | + for (var key in this._hash) |
| 143 | + if (key.indexOf(namespace) === 0) |
| 144 | + keys.push(_toKeyName(namespace, key)); |
| 145 | + return keys; |
123 | 146 | } |
124 | 147 | }; |
125 | 148 |
|
|
144 | 167 | }, |
145 | 168 | get: function (name) { |
146 | 169 | var cookies = document.cookie.split(';'); |
147 | | - |
148 | 170 | for (var i = 0; i < cookies.length; i++) { |
149 | 171 | var cookie = cookies[i].replace(/^\s*/, ''); |
150 | 172 | if (cookie.indexOf(name + '=') === 0) |
|
157 | 179 | return; |
158 | 180 | // remove cookie from main domain |
159 | 181 | this.set(name, '', { expireDays: -1 }); |
160 | | - |
161 | 182 | // remove cookie from upper domains |
162 | 183 | var domainParts = document.domain.split('.'); |
163 | 184 | for (var i = domainParts.length - 1; i > 0; i--) { |
|
166 | 187 | }, |
167 | 188 | reset: function (namespace) { |
168 | 189 | var cookies = document.cookie.split(';'); |
169 | | - |
170 | 190 | for (var i = 0; i < cookies.length; i++) { |
171 | 191 | var cookie = cookies[i].replace(/^\s*/, ''), |
172 | 192 | key = cookie.substr(0, cookie.indexOf('=')); |
173 | 193 | if (key.indexOf(namespace) === 0) |
174 | 194 | this.remove(key); |
175 | 195 | } |
| 196 | + }, |
| 197 | + keys: function (namespace) { |
| 198 | + var keys = [], |
| 199 | + cookies = document.cookie.split(';'); |
| 200 | + for (var i = 0; i < cookies.length; i++) { |
| 201 | + var cookie = cookies[i].replace(/^\s*/, ''), |
| 202 | + key = cookie.substr(0, cookie.indexOf('=')); |
| 203 | + if (key.indexOf(namespace) === 0) |
| 204 | + keys.push(_toKeyName(namespace, key)); |
| 205 | + } |
| 206 | + return keys; |
176 | 207 | } |
177 | 208 | }; |
178 | 209 |
|
179 | 210 | return { |
180 | 211 | init: function (options) { |
181 | 212 | this.options = Basil.utils.extend({}, Basil.options, options); |
182 | | - |
183 | 213 | this.supportedStorages = {}; |
184 | 214 | for (var i = 0, storage; i < this.options.storages.length; i++) { |
185 | 215 | storage = this.options.storages[i]; |
186 | 216 | if (_storages.hasOwnProperty(storage)) |
187 | 217 | this.supportedStorages[storage] = _storages[storage]; |
188 | 218 | } |
189 | | - |
190 | 219 | this.defaultStorage = this.check(this.options.storage) ? this.options.storage : this.detect(); |
191 | 220 | return this; |
192 | 221 | }, |
193 | 222 | detect: function () { |
194 | | - for (var storage in this.supportedStorages) { |
| 223 | + for (var storage in this.supportedStorages) |
195 | 224 | if (this.check(storage)) |
196 | 225 | return storage; |
197 | | - } |
198 | 226 | return null; |
199 | 227 | }, |
200 | 228 | check: function (storage) { |
|
204 | 232 | return false; |
205 | 233 | }, |
206 | 234 | set: function (name, value, options) { |
207 | | - if (!(name = _toStoredKey(this.options.namespace, name))) |
| 235 | + options = options || {}; |
| 236 | + if (!(name = _toStoredKey(options.namespace || this.options.namespace, name))) |
208 | 237 | return; |
209 | 238 | value = _toStoredValue(value); |
210 | 239 | options = Basil.utils.extend({ |
211 | 240 | expireDays: this.options.expireDays |
212 | 241 | }, options); |
213 | | - |
214 | 242 | var storages = _toStoragesArray(options.storages) || [this.defaultStorage]; |
215 | | - for (var i = 0; i < storages.length; i++) { |
216 | | - if (!this.check(storages[i])) |
| 243 | + for (var i = 0, storage; i < storages.length; i++) { |
| 244 | + storage = storages[i]; |
| 245 | + if (!this.check(storage)) |
217 | 246 | continue; |
218 | | - _storages[storages[i]].set(name, value, options); |
| 247 | + _storages[storage].set(name, value, options); |
219 | 248 | } |
220 | 249 | }, |
221 | 250 | get: function (name, options) { |
222 | | - if (!(name = _toStoredKey(this.options.namespace, name))) |
223 | | - return null; |
224 | 251 | options = options || {}; |
225 | | - |
| 252 | + if (!(name = _toStoredKey(options.namespace || this.options.namespace, name))) |
| 253 | + return null; |
226 | 254 | var value = null, |
227 | 255 | storages = _toStoragesArray(options.storages) || [this.defaultStorage]; |
228 | | - |
229 | | - for (var i = 0; value === null && i < storages.length; i++) { |
230 | | - if (!this.check(storages[i])) |
| 256 | + for (var i = 0, storage; value === null && i < storages.length; i++) { |
| 257 | + storage = storages[i]; |
| 258 | + if (!this.check(storage)) |
231 | 259 | continue; |
232 | | - value = _fromStoredValue(_storages[storages[i]].get(name)); |
| 260 | + value = _fromStoredValue(_storages[storage].get(name)); |
233 | 261 | } |
234 | 262 | return value; |
235 | 263 | }, |
236 | 264 | remove: function (name, options) { |
237 | | - if (!(name = _toStoredKey(this.options.namespace, name))) |
238 | | - return null; |
239 | 265 | options = options || {}; |
240 | | - |
| 266 | + if (!(name = _toStoredKey(options.namespace || this.options.namespace, name))) |
| 267 | + return null; |
241 | 268 | var storages = _toStoragesArray(options.storages) || [this.defaultStorage]; |
242 | | - for (var i = 0; i < storages.length; i++) { |
243 | | - if (!this.check(storages[i])) |
| 269 | + for (var i = 0, storage; i < storages.length; i++) { |
| 270 | + storage = storages[i]; |
| 271 | + if (!this.check(storage)) |
244 | 272 | continue; |
245 | | - _storages[storages[i]].remove(name); |
| 273 | + _storages[storage].remove(name); |
246 | 274 | } |
247 | 275 | }, |
248 | 276 | reset: function (options) { |
249 | 277 | options = options || {}; |
250 | | - |
251 | | - var storages = _toStoragesArray(options.storages) || [this.defaultStorage]; |
252 | | - for (var i = 0; i < storages.length; i++) { |
253 | | - if (!this.check(storages[i])) |
| 278 | + var storages = _toStoragesArray(options.storages) || [this.defaultStorage], |
| 279 | + namespace = options.namespace || this.options.namespace; |
| 280 | + for (var i = 0, storage; i < storages.length; i++) { |
| 281 | + storage = storages[i]; |
| 282 | + if (!this.check(storage)) |
254 | 283 | continue; |
255 | | - _storages[storages[i]].reset(this.options.namespace); |
| 284 | + _storages[storage].reset(namespace); |
| 285 | + } |
| 286 | + }, |
| 287 | + keys: function (options) { |
| 288 | + options = options || {}; |
| 289 | + var keys = []; |
| 290 | + for (var key in this.keysMap(options)) |
| 291 | + keys.push(key); |
| 292 | + return keys; |
| 293 | + }, |
| 294 | + keysMap: function (options) { |
| 295 | + options = options || {}; |
| 296 | + var map = {}, |
| 297 | + storages = _toStoragesArray(options.storages) || this.options.storages, |
| 298 | + namespace = options.namespace || this.options.namespace; |
| 299 | + for (var i = 0, storage, storageKeys; i < storages.length; i++) { |
| 300 | + storage = storages[i]; |
| 301 | + if (!this.check(storage)) |
| 302 | + continue; |
| 303 | + storageKeys = _storages[storage].keys(namespace); |
| 304 | + for (var j = 0, key; j < storageKeys.length; j++) { |
| 305 | + key = storageKeys[j]; |
| 306 | + map[key] = map[key] instanceof Array ? map[key] : []; |
| 307 | + map[key].push(storage); |
| 308 | + } |
256 | 309 | } |
| 310 | + return map; |
257 | 311 | }, |
258 | 312 | // Access to native storages, without namespace or basil value decoration |
259 | 313 | cookie: _storages.cookie, |
|
0 commit comments