javascriptmvc 3.0.0.pre15

data/lib/javascriptmvc/documentjs/json.js

@@ -0,0 +1,172 @@
+(function(){
+     var cx = /[\u0000\u00ad\u0600-\u0604\u070f\u17b4\u17b5\u200c-\u200f\u2028-\u202f\u2060-\u206f\ufeff\ufff0-\uffff]/g,
+	     isArray = function(arr){
+		 	return Object.prototype.toString.call(arr) === "[object Array]"
+		 }
+    
+    
+    JSONparse = function (text, reviver) {
+
+            var j;
+
+            function walk(holder, key) {
+                var k, v, value = holder[key];
+                if (value && typeof value === 'object') {
+                    for (k in value) {
+                        if (Object.hasOwnProperty.call(value, k)) {
+                            v = walk(value, k);
+                            if (v !== undefined) {
+                                value[k] = v;
+                            } else {
+                                delete value[k];
+                            }
+                        }
+                    }
+                }
+                return reviver.call(holder, key, value);
+            }
+
+            cx.lastIndex = 0;
+            if (cx.test(text)) {
+                text = text.replace(cx, function (a) {
+                    return '\\u' +
+                        ('0000' + a.charCodeAt(0).toString(16)).slice(-4);
+                });
+            }
+            if (/^[\],:{}\s]*$/.
+                test(text.replace(/\\(?:["\\\/bfnrt]|u[0-9a-fA-F]{4})/g, '@').
+                replace(/["'][^"\\\n\r]*["']|true|false|null|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?/g, ']').
+                replace(/(?:^|:|,)(?:\s*\[)+/g, ''))) {
+
+
+                j = eval('(' + text + ')');
+
+// In the optional fourth stage, we recursively walk the new structure, passing
+// each name/value pair to a reviver function for possible transformation.
+                return typeof reviver === 'function' ? walk({'': j}, '') : j;
+            }
+
+// If the text is not JSON parseable, then a SyntaxError is thrown.
+
+            throw new SyntaxError('JSONparse');
+        };
+    
+    
+	var toIntegersAtLease =function (n) 
+    // Format integers to have at least two digits.
+    {    
+        return n < 10 ? '0' + n : n;
+    }
+
+    Date.prototype.toJSON = function(date)
+    // Yes, it polutes the Date namespace, but we'll allow it here, as
+    // it's damned usefull.
+    {
+        return this.getUTCFullYear()   + '-' +
+             toIntegersAtLease(this.getUTCMonth()) + '-' +
+             toIntegersAtLease(this.getUTCDate());
+    };
+
+    var escapeable = /["\\\x00-\x1f\x7f-\x9f]/g;
+    var meta = {    // table of character substitutions
+            '\b': '\\b',
+            '\t': '\\t',
+            '\n': '\\n',
+            '\f': '\\f',
+            '\r': '\\r',
+            '"' : '\\"',
+            '\\': '\\\\'
+        };
+        
+    var quoteString = function(string)
+    // Places quotes around a string, inteligently.
+    // If the string contains no control characters, no quote characters, and no
+    // backslash characters, then we can safely slap some quotes around it.
+    // Otherwise we must also replace the offending characters with safe escape
+    // sequences.
+    {
+        if (escapeable.test(string))
+        {
+            return '"' + string.replace(escapeable, function (a) 
+            {
+                var c = meta[a];
+                if (typeof c === 'string') {
+                    return c;
+                }
+                c = a.charCodeAt();
+                return '\\u00' + Math.floor(c / 16).toString(16) + (c % 16).toString(16);
+            }) + '"';
+        }
+        return '"' + string + '"';
+    };
+    var vtoJSON = null;
+	var steal = steal;
+    vtoJSON = function(o, compact)
+    {
+        var type = typeof(o);
+        
+        if (type == "undefined")
+            return "undefined";
+        else if (type == "number" || type == "boolean")
+            return o + "";
+        else if (o === null)
+            return "null";
+        
+        // Is it a string?
+        if (type == "string") 
+        {
+            return quoteString(o);
+        }
+        
+        // Does it have a .toJSON function?
+        if (type == "object" && typeof o.toJSON == "function") 
+            return o.toJSON(compact);
+        
+        // Is it an array?
+        if(isArray(o))
+        {
+            var ret = [];
+            for (var i = 0; i < o.length; i++) {
+                ret.push( vtoJSON(o[i], compact) );
+            }
+            if (compact)
+                return "[" + ret.join(",") + "]";
+            else
+                return "[" + ret.join(", ") + "]";
+        }
+        
+        // If it's a function, we have to warn somebody!
+        if (type == "function") {
+            throw new TypeError("Unable to convert object of type 'function' to json.");
+        }
+        
+        // It's probably an object, then.
+        var ret = [];
+        for (var k in o) {
+            var name;
+            type = typeof(k);
+            
+            if (type == "number")
+                name = '"' + k + '"';
+            else if (type == "string")
+                name = quoteString(k);
+            else
+                continue;  //skip non-string or number keys
+            
+            var val = vtoJSON(o[k], compact);
+            if (typeof(val) != "string") {
+                // skip non-serializable values
+                continue;
+            }
+            
+            if (compact)
+                ret.push(name + ":" + val);
+            else
+                ret.push(name + ": " + val);
+        }
+        return "{" + ret.join(", ") + "}";
+    };
+	toJSON = vtoJSON;
+	
+	
+})();

data/lib/javascriptmvc/documentjs/page.js

@@ -0,0 +1,107 @@
+/**
+ * @hide
+ * Documents a 'Class'.  A class is typically a collection of static and prototype functions.
+ * steal Doc can automatically detect classes created with steal.Class.  However, you can make anything
+ * a class with the <b>@class <i>ClassName</i></b> directive.
+ * @author Jupiter IT
+ * @codestart
+ * /**
+ *  * Person represents a human with a name.  Read about the 
+ *  * animal class [Animal | here].
+ *  * @init 
+ *  * You must pass in a name.
+ *  * @params {String} name A person's name
+ *  *|
+ * Person = Animal.extend(
+ * /* @Static *|
+ * {
+ *    /* Number of People *|
+ *    count: 0
+ * },
+ * /* @Prototype *|
+ * {
+ *    init : function(name){
+ *      this.name = name
+ *      this._super({warmblood: true})
+ *    },
+ *    /* Returns a formal name 
+ *    * @return {String} the name with "Mrs." added
+ *    *|
+ *   fancy_name : function(){
+ *      return "Mrs. "+this.name;
+ *   }
+ * })
+ * @codeend
+ */
+DocumentJS.Pair.extend('DocumentJS.Page',
+/* @Static */
+{
+    starts_scope: true,
+    listing: [],
+    /**
+     * Loads the class view.
+     */
+    init : function(){
+        this.add(
+        DocumentJS.Directive.CodeStart, DocumentJS.Directive.CodeEnd,
+		DocumentJS.Directive.Tag, DocumentJS.Directive.iFrame, DocumentJS.Directive.Demo, DocumentJS.Directive.Parent)
+        
+        this._super();
+        
+        var ejs = "jmvc/plugins/documentation/templates/file.ejs"
+        
+		this.serialize("name",['real_comment','comment'],"shortName","title",['linker','children'])
+    }
+},
+/* @Prototype */
+{
+    /**
+     * Verifies the class was created successfully.
+     */
+    comment_setup_complete : function(){
+        if(!this.name){
+            print("Error! No name defined for \n-----------------------")
+            print(this.comment)
+            print('-----------------------')
+        }  
+    },
+
+    
+    code_setup: function(){
+        
+    },
+    page_add: function(line){
+        var m = line.match(/^@\w+\s+([^\s]+)\s+(.+)/)
+        if(m){
+            this.name = m[1];
+            this.title = m[2] || this.name;
+        }
+    },
+    /**
+     * Renders this class to a file.
+     * @param {String} left_side The left side content / list of all documented classes & constructors.
+     */
+    toFile : function(name){
+        try{
+            var res = this.jsonp();
+            new steal.File('apps/'+name+'/docs/'+this.name.replace(/ /g,"_")+".json").save(res);
+            
+        }catch(e ){
+            print("Unable to generate class for "+this.name+" !")
+            print("  Error: "+e)
+        }
+    },
+    cleaned_comment : function(){
+        return DocumentJS.link_content(this.real_comment).replace(/\n\s*\n/g,"<br/><br/>");
+    },
+	full_name : function(){
+		return this.name;
+	},
+	add_parent : function(scope){
+        //always go back to the file:
+        while(scope.Class.shortName.toLowerCase() != 'script') scope = scope.parent;
+        this.parent = scope.children.length ? scope.children[0] : scope;
+        this.parent.add(this);
+    }
+    
+});

data/lib/javascriptmvc/documentjs/pair.js

@@ -0,0 +1,302 @@
+/**
+ * A base class for a comment and the line of code following it.
+ * @hide
+ */
+DocumentJS.Class.extend("DocumentJS.Pair",
+/* @Static */
+{
+    code_match: function(){ return null},
+    classes: [],
+    /**
+     * From the comment and code, guesses at the type of comment and creates a new
+     * instance of that type.
+     * @param {String} comment - the comment
+     * @param {String} code - the first line of source following the comment
+     * @param {DocumentJS.Pair} scope - The current scope of documentation.  
+     * This is typically a Class, Constructor, Static, or Prototype
+     * @return {DocumentJS.Pair} - If a type can be found, the new Doc object; otherwise, null.
+     */
+    create: function(comment, code, scope){
+        var check =  comment.match(/^@(\w+)/), type
+
+        if(!(type = this.has_type(check ? check[1] : null)) ){ //try code
+            type = this.guess_type(code);
+        }
+        if(!type) return null;
+        
+		return new type(comment, code, scope)
+    },
+    /**
+     * Looks for a Doc class with a shortName for the given type
+     * @param {String} type a potential shortName
+     */
+    has_type: function(type){
+        if(!type) return null;
+		for(var i=0;i< this.classes.length; i++){
+            if(this.classes[i].shortName.toLowerCase() == type.toLowerCase() ) 
+                return this.classes[i];
+        }
+        return null;
+    },
+    /**
+     * Tries to guess at a piece of code's type.
+     * @param {Object} code
+     */
+    guess_type: function(code){
+
+		for(var i=0;i< this.classes.length; i++){
+            if(this.classes[i].code_match(code) ) 
+                return this.classes[i];
+        }
+        return null;
+    },
+	suggest_type : function(incorrect, line){
+		var lowest = 1000, suggest = "";
+		for(var i=0;i< this.classes.length; i++){
+            var dist = DocumentJS.distance(incorrect.toLowerCase(), this.classes[i].shortName.toLowerCase())
+			if(dist < lowest ){
+				lowest = dist
+				suggest = this.classes[i].shortName.toLowerCase()
+			} 
+        }
+		for(var i=0;i< DocumentJS.Directive.directives.length; i++){
+            var dist = DocumentJS.distance(incorrect.toLowerCase(),  DocumentJS.Directive.directives[i].toLowerCase())
+			if(dist < lowest ){
+				lowest = dist
+				suggest = DocumentJS.Directive.directives[i].toLowerCase()
+			} 
+        }
+		if(suggest){
+			print("\nWarning!!\nThere is no @"+incorrect+" directive. did you mean @"+suggest+" ?\n")
+		}
+	},
+    starts_scope: false,
+    /**
+     * Given a and b, sorts by their full_name property.
+     * @param {Object} a
+     * @param {Object} b
+     */
+    sort_by_full_name : function(a, b){
+       var af = a.full_name ? a.full_name.toLowerCase() : a.full_name
+       var bf = b.full_name ? b.full_name.toLowerCase() : a.full_name
+       if(af == bf) return 0;
+       return af > bf ? 1: -1;
+    },
+    sort_by_name : function(a, b){
+       var af = a.name ? a.name.toLowerCase() : a.name
+       var bf = b.name ? b.name.toLowerCase() : a.name
+       
+       if(af == bf) return 0;
+       return af > bf ? 1: -1;
+    },
+    /**
+     * Loads a template to use to render different doc types.
+     */
+    init : function(){
+		if(this.shortName){   
+			 if(DocumentJS.Pair)
+			 	DocumentJS.Pair.classes.push(this)
+        }
+		this.listing = [];
+    },
+    /**
+     * Adds [DocumentJS.Directive|directives] to this class.
+     * @codestart
+     * {
+     *   init: function(){
+     *     this._super();
+     *     this.add(DocumentJS.Directive.Return, DocumentJS.Directive.Param)
+     *   }
+     * }
+     * @codeend
+     */
+    add : function(){
+        var args = DocumentJS.makeArray(arguments)   
+        for(var i = 0; i < args.length; i++){
+            this._add(args[i]);
+        }
+    },
+    _add : function(directive){
+        var start = directive.shortName.toLowerCase()+"_"
+        this.prototype[start+"add"] = directive.prototype.add
+        if(directive.prototype.add_more)
+            this.prototype[start+"add_more"] = directive.prototype.add_more
+    },
+    matchDirective : /^\s*@(\w+)/
+},
+/* @Prototype */
+{
+    /**
+     * Saves coment, code.  Adds self to parent.  Calls code_setup and comment_setup.
+     * Finally, adds to DocumentJS.objects.
+     * @param {String} comment
+     * @param {String} code
+     * @param {DocumentJS.Pair} scope
+     */
+    init : function(comment, code, scope ){
+		this.children = [];
+		this.shallowParents = [];
+        this.comment = comment;
+        this.code = code;
+
+        
+        
+        if(this.Class.code_match(this.code))
+            this.code_setup();
+        this.comment_setup();
+        
+		//we need to add to a class if we 
+		this.add_parent(scope);
+        
+        var par = this;
+        while(par && !par.url){
+            par = par.parent;
+        }
+        if(par){
+            DocumentJS.objects[this.full_name()] = par.url()+(this.url ? "" : "#"+this.full_name() );
+        }
+		this.Class.listing.push(this);
+		if(DocumentJS.Directive.Parent.waiting.hasOwnProperty(this.name)){
+			var addOns = DocumentJS.Directive.Parent.waiting[this.name]
+			this.children = this.children.concat(addOns)
+			for(var i=0;i< addOns.length;i++){
+				addOns[i].shallowParents.push(this);
+			}
+		}
+    },
+    add: function(child){
+        this.children.push(child);
+    },
+    add_parent : function(scope){
+         this.parent = scope;
+         this.parent.add(this);
+    },
+    scope: function(){
+        return this.Class.starts_scope ? this : this.parent
+    },
+    code_setup: function(){},
+	jsonp: function(){
+		return "C("+$.toJSON(this.json())+")";
+	},
+    full_name: function(){
+        var par = ""
+        //print("has parent "+this.parent)
+		if(!this.parent){
+            print(this.name+" has no parent ")
+        }else
+            par = this.parent.full_name();
+        //print(par+" - "+this.name)
+		return (par ? par+"." : "")+this.name ;
+    },
+    make : function(arr){
+        var res = ["<div>"];
+        //we should alphabetize by name
+        
+        for(var c=0; c<arr.length; c++){
+            var child = arr[c];
+            res.push(child.toHTML());
+        }
+        res.push("</div>");
+        return res.join("");
+    },
+	/**
+	 * Checks if this child should not add its children for the given parent
+	 */
+	shallowParent : function(parent){
+		for(var i = 0; i < this.shallowParents.length;i++){
+			if(this.shallowParents[i] === parent){
+				return true;
+			}
+		}
+		return false;
+	},
+    linker : function(stealSelf, parent){
+        var result = stealSelf ? [ {name: this.full_name(), shortName : this.Class.shortName.toLowerCase(), title: this.title, hide: (this.hide ? true: false) }] : [];
+		if(this.children && ! this.shallowParent(parent)){
+            //print(this.name)
+			for(var c=0; c<this.children.length; c++){
+                var adds = this.children[c].linker(true, this);
+                if(adds)
+                    result = result.concat( adds );
+            }
+        }
+        return result;
+    },
+    /**
+     * Orders params into an array.
+     */
+    ordered_params : function(){
+            var arr = [];
+            for(var n in this.params){
+                var param = this.params[n];
+                arr[param.order] = param;
+            }
+            return arr;
+    },
+    /**
+     * Goes through the comment line by line.  Searches for lines starting with a <i>@directive</i>.
+     * If a line with a directive is found, it sees if the instance has a function that matches
+     * <i>directive</i>_add exists.  If it does, <i>directive</i>_add is called on that object.
+     * If following lines do not have a directive, the <i>directive</i>_add_more function is called
+     * on the instance
+     * <br/>
+     * Initial comments are added to real_comment.<br>
+     * This function is shared by Class and Constructor.
+     */
+    comment_setup: function(){
+        var i = 0,
+			lines = this.comment.split("\n"),
+			last, 
+			last_data; //what data we are going to be called with
+        
+		this.real_comment = '';
+        if(!this.params) this.params = {};
+        if(!this.ret) this.ret = {type: 'undefined',description: ""};
+		
+		this._last; //what we should be adding too.
+		
+        for(var l=0; l < lines.length; l++){
+            var line = lines[l],
+				match = line.match(DocumentJS.Pair.matchDirective)
+            
+			if (match) {
+			
+				var fname = (match[1] + '_add').toLowerCase();
+				if (!this[fname]) {
+					if (!DocumentJS.Pair.has_type(match[1])) {
+						DocumentJS.Pair.suggest_type(match[1])
+					}
+					
+					this.real_comment += line + "\n"
+					continue;
+				}
+				last_data = this[fname](line, last_data);
+				//horrible ... fix
+				if (last_data && last_data.length == 2 && last_data[0] == 'keep') {
+					last_data = last_data[1]
+				}
+				else 
+					if (last_data) {
+						this._last = match[1].toLowerCase();
+					}
+					else {
+						this._last = null;
+					}
+				
+			}
+			else {
+				line = line.replace(/@@/g,"@")
+				if (!line.match(/^constructor/i) && !this._last) {
+					this.real_comment += line + "\n"
+				}
+				else if (this._last && this[this._last + '_add_more']) {
+					this[this._last + '_add_more'](line, last_data);
+				}
+			}
+        }
+        if(this.comment_setup_complete) this.comment_setup_complete();
+    },
+	shortName : function(){
+		return this.Class.shortName;
+	}
+})