javascriptmvc 3.0.0.pre15

data/lib/javascriptmvc/jquery/view/jaml/node.js

@@ -0,0 +1,149 @@
+/**
+ * @constructor
+ * @init
+ * @param {String} tagName The tag name this node represents (e.g. 'p', 'div', etc)
+ */
+Jaml.Node = function(tagName) {
+  /**
+   * @attribute tagName
+   * @type String
+   * This node's current tag
+   */
+  this.tagName = tagName;
+  
+  /**
+   * @attribute attributes
+   * @type Object
+   * Sets of attributes on this node (e.g. 'cls', 'id', etc)
+   */
+  this.attributes = {};
+  
+  /**
+   * @attribute children
+   * @type Array
+   * Array of rendered child nodes that will be steald as this node's innerHTML
+   */
+  this.children = [];
+};
+
+Jaml.Node.prototype = {
+  /**
+   * Adds attributes to this node
+   * @param {Object} attrs Object containing key: value pairs of node attributes
+   */
+  setAttributes: function(attrs ) {
+    for (var key in attrs) {
+      //convert cls to class
+      var mappedKey = key == 'cls' ? 'class' : key;
+      
+      this.attributes[mappedKey] = attrs[key];
+    }
+  },
+  
+  /**
+   * Adds a child string to this node. This can be called as often as needed to add children to a node
+   * @param {String} childText The text of the child node
+   */
+  addChild: function(childText ) {
+    this.children.push(childText);
+  },
+  
+  /**
+   * Renders this node with its attributes and children
+   * @param {Number} lpad Amount of whitespace to add to the left of the string (defaults to 0)
+   * @return {String} The rendered node
+   */
+  render: function(lpad ) {
+    lpad = lpad || 0;
+    
+    var node      = [],
+        attrs     = [],
+        textnode  = (this instanceof Jaml.TextNode),
+        multiline = this.multiLineTag();
+    
+    for (var key in this.attributes) {
+      attrs.push(key + '=' + this.attributes[key]);
+    }
+    
+    //add any left padding
+    if (!textnode) node.push(this.getPadding(lpad));
+    
+    //open the tag
+    node.push("<" + this.tagName);
+    
+    //add any tag attributes
+    for (var key in this.attributes) {
+      node.push(" " + key + "=\"" + this.attributes[key] + "\"");
+    }
+    
+    if (this.isSelfClosing()) {
+      node.push(" />\n");
+    } else {
+      node.push(">");
+      
+      if (multiline) node.push("\n");
+      
+      for (var i=0; i < this.children.length; i++) {
+        node.push(this.children[i].render(lpad + 2));
+      }
+      
+      if (multiline) node.push(this.getPadding(lpad));
+      node.push("</", this.tagName, ">\n");
+    }
+    
+    return node.join("");
+  },
+  
+  /**
+   * Returns true if this tag should be rendered with multiple newlines (e.g. if it contains child nodes)
+   * @return {Boolean} True to render this tag as multi-line
+   */
+  multiLineTag: function() {
+    var childLength = this.children.length,
+        multiLine   = childLength > 0;
+    
+    if (childLength == 1 && this.children[0] instanceof Jaml.TextNode) multiLine = false;
+    
+    return multiLine;
+  },
+  
+  /**
+   * Returns a string with the given number of whitespace characters, suitable for padding
+   * @param {Number} amount The number of whitespace characters to add
+   * @return {String} A padding string
+   */
+  getPadding: function(amount ) {
+    return new Array(amount + 1).join(" ");
+  },
+  
+  /**
+   * Returns true if this tag should close itself (e.g. no </tag> element)
+   * @return {Boolean} True if this tag should close itself
+   */
+  isSelfClosing: function() {
+    var selfClosing = false;
+    
+    for (var i = this.selfClosingTags.length - 1; i >= 0; i--){
+      if (this.tagName == this.selfClosingTags[i]) selfClosing = true;
+    }
+    
+    return selfClosing;
+  },
+  
+  /**
+   * @attribute selfClosingTags
+   * @type Array
+   * An array of all tags that should be self closing
+   */
+  selfClosingTags: ['img', 'meta', 'br', 'hr']
+};
+
+Jaml.TextNode = function(text) {
+  this.text = text;
+};
+
+Jaml.TextNode.prototype = {
+  render: function() {
+    return this.text;
+  }
+};

data/lib/javascriptmvc/jquery/view/jaml/template.js

@@ -0,0 +1,131 @@
+/**
+ * Represents a single registered template. Templates consist of an arbitrary number
+ * of trees (e.g. there may be more than a single root node), and are not compiled.
+ * When a template is rendered its node structure is computed with any provided template
+ * data, culminating in one or more root nodes.  The root node(s) are then joined together
+ * and returned as a single output string.
+ * 
+ * The render process uses two dirty but necessary hacks.  First, the template function is
+ * decompiled into a string (but is not modified), so that it can be eval'ed within the scope
+ * of Jaml.Template.prototype. This allows the second hack, which is the use of the 'with' keyword.
+ * This allows us to keep the pretty DSL-like syntax, though is not as efficient as it could be.
+ */
+Jaml.Template = function(tpl) {
+  /**
+   * @attribute tpl
+   * @type Function
+   * The function this template was created from
+   */
+  this.tpl = tpl;
+  
+  this.nodes = [];
+};
+
+Jaml.Template.prototype = {
+  /**
+   * Renders this template given the supplied data
+   * @param {Object} data Optional data object
+   * @return {String} The rendered HTML string
+   */
+  render: function(data ) {
+    data = data || {};
+    
+    //the 'data' argument can come in two flavours - array or non-array. Normalise it
+    //here so that it always looks like an array.
+    if (data.constructor.toString().indexOf("Array") == -1) {
+      data = [data];
+    }
+    
+    with(this) {
+      for (var i=0; i < data.length; i++) {
+        eval("(" + this.tpl.toString() + ")(data[i])");
+      };
+    }
+    
+    var roots  = this.getRoots(),
+        output = "";
+    
+    for (var i=0; i < roots.length; i++) {
+      output += roots[i].render();
+    };
+    
+    return output;
+  },
+  
+  /**
+   * Returns all top-level (root) nodes in this template tree.
+   * Templates are tree structures, but there is no guarantee that there is a
+   * single root node (e.g. a single DOM element that all other elements nest within)
+   * @return {Array} The array of root nodes
+   */
+  getRoots: function() {
+    var roots = [];
+    
+    for (var i=0; i < this.nodes.length; i++) {
+      var node = this.nodes[i];
+      
+      if (node.parent == undefined) roots.push(node);
+    };
+    
+    return roots;
+  },
+  
+  tags: [
+    "html", "head", "body", "script", "meta", "title", "link", "script",
+    "div", "p", "span", "a", "img", "br", "hr",
+    "table", "tr", "th", "td", "thead", "tbody",
+    "ul", "ol", "li", 
+    "dl", "dt", "dd",
+    "h1", "h2", "h3", "h4", "h5", "h6", "h7",
+    "form", "input", "label"
+  ]
+};
+
+/**
+ * Adds a function for each tag onto Template's prototype
+ */
+(function() {
+  var tags = Jaml.Template.prototype.tags;
+  
+  for (var i = tags.length - 1; i >= 0; i--){
+    var tagName = tags[i];
+    
+    /**
+     * This function is created for each tag name and assigned to Template's
+     * prototype below
+     */
+    var fn = function(tagName) {
+      return function(attrs) {
+        var node = new Jaml.Node(tagName);
+        
+        var firstArgIsAttributes =  (typeof attrs == 'object')
+                                 && !(attrs instanceof Jaml.Node)
+                                 && !(attrs instanceof Jaml.TextNode);
+
+        if (firstArgIsAttributes) node.setAttributes(attrs);
+
+        var startIndex = firstArgIsAttributes ? 1 : 0;
+
+        for (var i=startIndex; i < arguments.length; i++) {
+          var arg = arguments[i];
+
+          if (typeof arg == "string" || arg == undefined) {
+            arg = new Jaml.TextNode(arg || "");
+          }
+          
+          if (arg instanceof Jaml.Node || arg instanceof Jaml.TextNode) {
+            arg.parent = node;
+          }
+
+          node.addChild(arg);
+        };
+        
+        this.nodes.push(node);
+        
+        return node;
+      };
+    };
+    
+    Jaml.Template.prototype[tagName] = fn(tagName);
+  };
+})();

data/lib/javascriptmvc/jquery/view/jaml/test/funcunit/funcunit.js

@@ -0,0 +1,3 @@
+steal
+ .plugins("steal/test/funcunit")  //load funcunit
+ .then("jaml_test")       //load your tests

data/lib/javascriptmvc/jquery/view/jaml/test/funcunit/jaml_test.js

@@ -0,0 +1,11 @@
+module("jaml")
+
+
+test("jaml testing works", function(){
+
+        S.open("file:/c:/Development/steal/jquery/view/jaml/jaml.html");
+		S.wait(10, function(){
+			ok(true, "things working");
+		})
+
+})

data/lib/javascriptmvc/jquery/view/jaml/test/funcunit/run.js

@@ -0,0 +1,10 @@
+//load("jquery/view/jaml/test/funcunit/run.js")
+
+
+//load global selenium settings, change if you want something different
+load('settings/selenium.js')
+
+load('steal/rhino/loader.js');
+rhinoLoader(function(){
+    steal.plugins('jquery/view/jaml/test/funcunit');  // load tests
+}, true);

data/lib/javascriptmvc/jquery/view/jaml/test/qunit/jaml_test.js

@@ -0,0 +1,4 @@
+module("jaml")
+test("jaml testing works", function(){
+	ok(true,"an assert is run")
+})

data/lib/javascriptmvc/jquery/view/jaml/test/qunit/qunit.html

@@ -0,0 +1,21 @@
+<html>
+    <head>
+        <link rel="stylesheet" type="text/css" href="../../../../../steal/test/qunit/qunit.css" />
+        <style>
+            body  {
+                margin: 0px; padding: 0px;
+            }
+        </style>
+		<script type='text/javascript' src='../../../../../steal/steal.js?steal[app]=jquery/view/jaml/test/qunit'></script>
+    </head>
+    <body>
+
+        <h1 id="qunit-header">jaml Test Suite</h1>
+    	<h2 id="qunit-banner"></h2>
+    	<div id="qunit-testrunner-toolbar"></div>
+    	<h2 id="qunit-userAgent"></h2>
+		<div id="test-content"></div>
+        <ol id="qunit-tests"></ol>
+		<div id="qunit-test-area"></div>
+    </body>
+</html>

data/lib/javascriptmvc/jquery/view/jaml/test/qunit/qunit.js

@@ -0,0 +1,9 @@
+//we probably have to have this only describing where the tests are
+steal
+ .plugins("jquery/view/jaml")  //load your app
+ .plugins('funcunit/qunit')  //load qunit
+ .then("jaml_test")
+ 
+if(steal.browser.rhino){
+  steal.plugins('funcunit/qunit/env')
+}

data/lib/javascriptmvc/jquery/view/jaml/test/qunit/run.js

@@ -0,0 +1,2 @@
+load('steal/rhino/env.js');
+Envjs('jaml/test/qunit/qunit.html', {scriptTypes : {"text/javascript" : true,"text/envjs" : true}, fireLoad: true, logLevel: 2});

data/lib/javascriptmvc/jquery/view/micro/compress.js

@@ -0,0 +1,7 @@
+//js micro/compress.js
+
+var compressPage = 'micro/micro.html';
+var outputFolder = 'micro';
+load("steal/compress/compress.js")
+var compress = new Steal.Compress([compressPage, outputFolder]);
+compress.init();

data/lib/javascriptmvc/jquery/view/micro/funcunit.html

@@ -0,0 +1,21 @@
+<html>
+    <head>
+        <link rel="stylesheet" type="text/css" href="../../../steal/test/qunit/qunit.css" />
+        <style>
+            body  {
+                margin: 0px; padding: 0px;
+            }
+        </style>
+		<script type='text/javascript' src='../../../steal/steal.js?steal[app]=jquery/view/micro/test/funcunit'></script>
+    </head>
+    <body>
+
+        <h1 id="qunit-header">micro Test Suite</h1>
+    	<h2 id="qunit-banner"></h2>
+    	<div id="qunit-testrunner-toolbar"></div>
+    	<h2 id="qunit-userAgent"></h2>
+		<div id="test-content"></div>
+        <ol id="qunit-tests"></ol>
+		<div id="qunit-test-area"></div>
+    </body>
+</html>

data/lib/javascriptmvc/jquery/view/micro/micro.html

@@ -0,0 +1,25 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN"
+            "http://www.w3.org/TR/html4/strict.dtd">
+<html lang="en">
+	<head>
+		<title>micro</title>
+        <style type='text/css'>
+            body {font-family: verdana}
+            .error {border: solid 1px red;}
+            .error_text { color: red; font-size: 10px;}
+            td {padding: 3px;}
+        </style>
+	</head>
+	<body>
+	    <h1>Welcome to JavaScriptMVC 3.0!</h1>
+        <ul>
+            <li>Include plugins and files in <i>jquery/view/micro/micro.js</i>.</li>
+            <li>Change to production mode by changing <i>development</i> to <i>production</i> in this file.</li>
+        </ul>
+		<script type='text/javascript' 
+                src='../../../steal/steal.js?steal[app]=jquery/view/micro&steal[env]=development'
+                package='main.js'
+                compress='false'>   
+        </script>
+	</body>
+</html>

data/lib/javascriptmvc/jquery/view/micro/micro.js

@@ -0,0 +1,57 @@
+steal.plugins('jquery/view').then(function(){
+// Simple JavaScript Templating
+// John Resig - http://ejohn.org/ - MIT Licensed
+
+  var cache = {};
+  
+  function MicroTemplate(str, data){
+	var body =  
+		"var p=[],print=function(){p.push.apply(p,arguments);};" +
+        
+        // Introduce the data as local variables using with(){}
+        "with(obj){p.push('" +
+        
+        // Convert the template into pure JavaScript
+        str.replace(/[\r\t\n]/g, " ")
+   .replace(/'(?=[^%]*%})/g,"\t")
+   .split("'").join("\\'")
+   .split("\t").join("'")
+   .replace(/{%=(.+?)%}/g, "',$1,'")
+   .split("{%").join("');")
+   .split("%}").join("p.push('")+ "');}return p.join('');"
+	
+    var fn =  new Function("obj",body);
+	fn.body = body;
+    
+    // Provide some basic currying to the user
+    return data ? fn( data ) : fn;
+  };
+
+	$.View.register({
+		suffix : "micro",
+		renderer: function( id, text ) {
+			var mt = MicroTemplate(text)
+			return function(data){
+				return mt(data)
+			}
+		},
+		get: function( id, url ) {
+			var text = $.ajax({
+					async: false,
+					url: url,
+					dataType: "text",
+					error: function() {
+						throw "micro.js ERROR: There is no template or an empty template at "+url;
+					}
+				}).responseText
+			return this.renderer(id, text);
+			
+		},
+		script: function( id, str ) {
+			return "function(obj){"+MicroTemplate(str).body+"}";
+		}
+	})
+	jQuery.View.ext = ".micro"
+	
+
+});