Fixed can.Construct-derived static properties being inaccessible in M…

…ustache #450

Also fixed consistency issues in handling helper arguments

compute/compute.js

@@ -602,6 +602,7 @@ steal('can/util', 'can/util/bind', 'can/util/batch', function (can, bind) {
 				// just do the dot operator
 				cur = prev[reads[i]];
 			}
+			type = typeof cur;
 			// If it's a compute, get the compute's value
 			// unless we are at the end of the 
 			if (cur && cur.isComputed && (!options.isArgument && i < readLength - 1)) {
@@ -610,7 +611,10 @@ steal('can/util', 'can/util/bind', 'can/util/batch', function (can, bind) {
 				}
 				cur = cur();
 			}
-			type = typeof cur;
+			// If it's an anonymous function, execute as requested
+			else if (i < reads.length - 1 && type === 'function' && options.executeAnonymousFunctions && !(can.Construct && cur.prototype instanceof can.Construct)) {
+				cur = cur();
+			} 
 			// if there are properties left to read, and we don't have an object, early exit
 			if (i < reads.length - 1 && (cur === null || type !== 'function' && type !== 'object')) {
 				if (options.earlyExit) {
@@ -624,7 +628,8 @@ steal('can/util', 'can/util/bind', 'can/util/batch', function (can, bind) {
 			}
 		}
 		// handle an ending function
-		if (typeof cur === 'function') {
+		// unless it is a can.Construct-derived constructor
+		if (typeof cur === 'function' && !(can.Construct && cur.prototype instanceof can.Construct)) {
 			if (options.isArgument) {
 				if (!cur.isComputed && options.proxyMethods !== false) {
 					cur = can.proxy(cur, prev);

view/mustache/mustache.js

@@ -1351,7 +1351,7 @@ steal('can/util',
 					// get values on hash
 					for (var prop in hash) {
 						if (isLookup(hash[prop])) {
-							hash[prop] = Mustache.get(hash[prop].get, scopeAndOptions);
+							hash[prop] = Mustache.get(hash[prop].get, scopeAndOptions, false, true);
 						}
 					}
 				} else if (arg && isLookup(arg)) {

view/mustache/mustache_test.js

@@ -3626,4 +3626,57 @@ steal("can/model", "can/view/mustache", "can/test", "can/view/mustache/spec/spec
 		data.attr("show", true);
 		equal(frag.childNodes[0].innerHTML, "Is showing", "Not showing the else");
 	});
+
+	test("can.Construct derived classes should be considered objects, not functions (#450)", 8, function() {
+		can.Mustache.registerHelper("cat", function(options) {
+			var clazz = options.hash ? options.hash.clazz : options;
+			// When using the anonymous function containing foostructor, it will need to be executed
+			return clazz.text || clazz().text;
+		});
+
+		var foostructor = can.Map({ text: "bar" }, {}),
+			obj = {
+				next_level: {
+					thing: foostructor,
+					text: "In the inner context"
+				}
+			},
+			div = document.createElement("div"),
+			description;
+		foostructor.self = foostructor;
+		window.other_text = "Window context";
+
+		for (var i = 0; i < 2; i++) {
+			if (i === 1) {
+				foostructor.self = function() { return foostructor; };
+			}
+
+			// // Fully dotted
+			div.appendChild(can.view.mustache("<div>{{next_level.thing.self.text}}</div>")(obj));
+
+			// // With attribute nested
+			div.appendChild(can.view.mustache("<div>{{#next_level.thing.self}}{{text}}{{/next_level.thing}}</div>")(obj));
+
+			// Passed as an argument to helper
+			div.appendChild(can.view.mustache("<div>{{cat next_level.thing.self}}</div>")(obj));
+
+			// Passed as a hash to helper
+			div.appendChild(can.view.mustache("<div>{{cat clazz=next_level.thing.self}}</div>")(obj));
+		}
+
+		var content = div.getElementsByTagName('div');
+
+		description = " (constructor by itself)";
+		equal(content[0].innerHTML, "bar", "fully dotted" + description);
+		equal(content[1].innerHTML.replace(/\<\/?span\>/g,''), "", "with attribute nested" + description);
+		equal(content[2].innerHTML, "bar", "passed as an argument to helper" + description);
+		equal(content[3].innerHTML, "bar", "passed as a hash to helper" + description);
+
+		description = " (constructor as function returning itself)";
+		equal(content[4].innerHTML, "bar", "fully dotted" + description);
+		equal(content[5].innerHTML.replace(/\<\/?span\>/g,''), "", "with attribute nested" + description);
+		equal(content[6].innerHTML, "bar", "passed as an argument to helper" + description);
+		equal(content[7].innerHTML, "bar", "passed as a hash to helper" + description);
+	});
+
 });

view/scope/scope.js

@@ -253,7 +253,9 @@ steal(
 										/* Clear and save readings so next attempt does not use these readings */
 										defaultComputeReadings = can.__clearReading();
 									}
-								}
+								},
+								// Execute anonymous functions found along the way
+								executeAnonymousFunctions: true
 							}, options));
 							// **Key was found**, return value and location data
 							if (data.value !== undefined) {