commit b88b767b0b060fc8bf542a2a652497e91932070c
parent 50eddb05eed9ed045aae2487b6d7a84f8e382b53
Author: Dan Stillman <dstillman@zotero.org>
Date: Tue, 14 Mar 2006 11:45:19 +0000
Renamed DB to scholar.sqlite, since that seems to be the current fashion
Added some new core functions:
- Scholar.varDump(), after PHP's var_dump()
- Scholar.flattenArguments(), to flatten mixed array/literal argument lists into a single array
- Scholar.join() -- a version of join() that operates externally, for use on, for example, the arguments object (safer than extending Object)
- Scholar.Hash, a slightly smarter associative array -- not perfect, but brings a proper length property and a few convenience methods (and allows for other additions) -- should probably be limited to places where the length property or other additional additions are needed, since its use is a little non-standard (e.g. you have to remember to do _for (i in arr.items)_ rather than just _for (i in arr)_, to use set(), etc.)
Diffstat:
1 file changed, 160 insertions(+), 4 deletions(-)
diff --git a/chrome/chromeFiles/content/scholar/scholar.js b/chrome/chromeFiles/content/scholar/scholar.js
@@ -1,7 +1,9 @@
const SCHOLAR_CONFIG = {
- DB_FILE : 'scholar.sdb',
- DB_VERSION : 1,
- DEBUG_LOGGING : true
+ GUID: 'scholar@chnm',
+ DB_FILE: 'scholar.sqlite',
+ DB_VERSION: 2,
+ DB_REBUILD: false, // erase DB and recreate from schema
+ DEBUG_LOGGING: true
};
/*
@@ -12,9 +14,10 @@ var Scholar = {
* Initialize the extension
*/
init: function() {
- scholarDB.updateSchema();
+ Scholar_DB.updateSchema();
},
+
/*
* Debug logging function
*
@@ -47,7 +50,160 @@ var Scholar = {
dump('scholar(' + level + '): ' + message);
}
return true;
+ },
+
+
+ /**
+ * PHP var_dump equivalent for JS
+ *
+ * Adapted from http://binnyva.blogspot.com/2005/10/dump-function-javascript-equivalent-of.html
+ */
+ varDump: function(arr,level) {
+ var dumped_text = "";
+ if (!level){
+ level = 0;
+ }
+
+ // The padding given at the beginning of the line.
+ var level_padding = "";
+ for (var j=0;j<level+1;j++){
+ level_padding += " ";
+ }
+
+ if (typeof(arr) == 'object') { // Array/Hashes/Objects
+ for (var item in arr) {
+ var value = arr[item];
+
+ if (typeof(value) == 'object') { // If it is an array,
+ dumped_text += level_padding + "'" + item + "' ...\n";
+ dumped_text += arguments.callee(value,level+1);
+ }
+ else {
+ if (typeof value == 'function'){
+ dumped_text += level_padding + "'" + item + "' => function(...){...} \n";
+ }
+ else {
+ dumped_text += level_padding + "'" + item + "' => \"" + value + "\"\n";
+ }
+ }
+ }
+ }
+ else { // Stings/Chars/Numbers etc.
+ dumped_text = "===>"+arr+"<===("+typeof(arr)+")";
+ }
+ return dumped_text;
+ },
+
+
+ /*
+ * Flattens mixed arrays/values in a passed _arguments_ object and returns
+ * an array of values -- allows for functions to accept both arrays of
+ * values and/or an arbitrary number of individual values
+ */
+ flattenArguments: function(args){
+ var returns = new Array();
+
+ for (var i=0; i<args.length; i++){
+ if (typeof args[i]=='object'){
+ for (var j=0; j<args[i].length; j++){
+ returns.push(args[i][j]);
+ }
+ }
+ else {
+ returns.push(args[i]);
+ }
+ }
+
+ return returns;
+ },
+
+
+ /*
+ * A version of join() that operates externally for use on objects other
+ * than arrays (e.g. _arguments_)
+ *
+ * Note that this is safer than extending Object()
+ */
+ join: function(obj, delim){
+ var a = [];
+ for (var i=0, len=obj.length; i<len; i++){
+ a.push(obj[i]);
+ }
+ return a.join(delim);
+ },
+
+
+ /*
+ * Class for creating hash arrays that behave a bit more sanely
+ *
+ * Hashes can be created in the constructor by alternating key and val:
+ *
+ * var hasharray = new Scholar.Hash('foo','foovalue','bar','barvalue');
+ *
+ * Or using hasharray.set(key, val)
+ *
+ * _val_ defaults to true if not provided
+ *
+ * If using foreach-style looping, be sure to use _for (i in arr.items)_
+ * rather than just _for (i in arr)_, or else you'll end up with the
+ * methods and members instead of the hash items
+ *
+ * Most importantly, hasharray.length will work as expected, even with
+ * non-numeric keys
+ *
+ * Adapated from http://www.mojavelinux.com/articles/javascript_hashes.html
+ * (c) Mojavelinux, Inc.
+ * License: Creative Commons
+ */
+ Hash: function(){
+ this.length = 0;
+ this.items = new Array();
+
+ // Public methods defined on prototype below
+
+ for (var i = 0; i < arguments.length; i += 2) {
+ if (typeof(arguments[i + 1]) != 'undefined') {
+ this.items[arguments[i]] = arguments[i + 1];
+ this.length++;
+ }
+ }
+ }
+};
+
+
+Scholar.Hash.prototype.get = function(in_key){
+ return this.items[in_key];
+}
+
+Scholar.Hash.prototype.set = function(in_key, in_value){
+ // Default to a boolean hash if value not provided
+ if (typeof(in_value) == 'undefined'){
+ in_value = true;
+ }
+
+ if (typeof(this.items[in_key]) == 'undefined') {
+ this.length++;
+ }
+
+ this.items[in_key] = in_value;
+
+ return in_value;
+}
+
+Scholar.Hash.prototype.remove = function(in_key){
+ var tmp_value;
+ if (typeof(this.items[in_key]) != 'undefined') {
+ this.length--;
+ var tmp_value = this.items[in_key];
+ delete this.items[in_key];
}
+
+ return tmp_value;
}
+Scholar.Hash.prototype.has = function(in_key){
+ return typeof(this.items[in_key]) != 'undefined';
+}
+
+
window.addEventListener("load", function(e) { Scholar.init(e); }, false);
