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.)

chrome/chromeFiles/content/scholar/scholar.js

@@ -1,7 +1,9 @@
 const SCHOLAR_CONFIG = {
-	DB_FILE : 'scholar.sdb',
+	GUID: 'scholar@chnm',
-	DB_VERSION : 1,
+	DB_FILE: 'scholar.sqlite',
-	DEBUG_LOGGING : true
+	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);