canjs-rails 0.1.0 → 1.1.2

data/CHANGELOG.md

@@ -1,3 +1,8 @@
+## 1.1.2 (28 November 2012)
+
+- updated to use canjs v1.1.2
+- updated version to stay be in sync with Can.JS
+
 ## 0.1.0 (26 June 2012)
 
 - initial release

data/canjs-rails.gemspec

@@ -9,7 +9,7 @@ Gem::Specification.new do |s|
   s.email       = ["craig@mindscratch.org"]
   s.homepage    = "https://github.com/mindscratch/canjs-rails"
   s.summary     = "Use CanJS with Rails 3.1+"
-  s.description = "This gem provides CanJS for your Rails 3.1+ application."
+  s.description = "This gem provides CanJS (for jQuery) for your Rails 3.1+ application."
 
   s.required_rubygems_version = ">= 1.3.6"
   s.rubyforge_project         = "canjs-rails"

data/lib/canjs/rails/version.rb

@@ -1,6 +1,6 @@
 module Canjs
   module Rails
-    VERSION = "0.1.0"
-    CANJS_VERSION = "1.0.7"
+    VERSION = "1.1.2"
+    CANJS_VERSION = "1.1.2"
   end
 end

data/vendor/assets/javascripts/can.construct.proxy.js

@@ -1,9 +1,16 @@
-(function(can, window, undefined){
-var isFunction = can.isFunction,
-	isArray = can.isArray,
-	makeArray = can.makeArray,
-
-proxy = function( funcs ) {
+/*
+* CanJS - 1.1.2 (2012-11-28)
+* http://canjs.us/
+* Copyright (c) 2012 Bitovi
+* Licensed MIT
+*/
+(function (can, window, undefined) {
+	// ## can/construct/proxy/proxy.js
+	var isFunction = can.isFunction,
+		isArray = can.isArray,
+		makeArray = can.makeArray,
+
+		proxy = function (funcs) {
 
 			//args that should be curried
 			var args = makeArray(arguments),
@@ -13,48 +20,42 @@ proxy = function( funcs ) {
 			funcs = args.shift();
 
 			// if there is only one function, make funcs into an array
-			if (!isArray(funcs) ) {
+			if (!isArray(funcs)) {
 				funcs = [funcs];
 			}
-			
+
 			// keep a reference to us in self
 			self = this;
-			
-			
+
+
 			return function class_cb() {
 				// add the arguments after the curried args
 				var cur = args.concat(makeArray(arguments)),
-					isString, 
-					length = funcs.length,
+					isString, length = funcs.length,
 					f = 0,
 					func;
-				
+
 				// go through each function to call back
-				for (; f < length; f++ ) {
+				for (; f < length; f++) {
 					func = funcs[f];
-					if (!func ) {
+					if (!func) {
 						continue;
 					}
-					
+
 					// set called with the name of the function on self (this is how this.view works)
 					isString = typeof func == "string";
-					
+
 					// call the function
 					cur = (isString ? self[func] : func).apply(self, cur || []);
-					
+
 					// pass the result to the next function (if there is a next function)
-					if ( f < length - 1 ) {
+					if (f < length - 1) {
 						cur = !isArray(cur) || cur._use_call ? [cur] : cur
 					}
 				}
 				return cur;
 			}
 		}
-	can.Construct.proxy = can.Construct.prototype.proxy = proxy;
-	
-	
-
-
-
+		can.Construct.proxy = can.Construct.prototype.proxy = proxy;
 
-})(this.can, this )
+})(can, this);

data/vendor/assets/javascripts/can.construct.super.js

@@ -1,44 +1,48 @@
-(function(can, window, undefined){
-
-// tests if we can get super in .toString()
+/*
+* CanJS - 1.1.2 (2012-11-28)
+* http://canjs.us/
+* Copyright (c) 2012 Bitovi
+* Licensed MIT
+*/
+(function (can, window, undefined) {
+	// ## can/construct/super/super.js
+	// tests if we can get super in .toString()
 	var isFunction = can.isFunction,
-		
-		fnTest = /xyz/.test(function() {
+
+		fnTest = /xyz/.test(function () {
 			xyz;
 		}) ? /\b_super\b/ : /.*/;
-		
-		// overwrites a single property so it can still call super
-		can.Construct._overwrite = function(addTo, base, name, val){
-			// Check if we're overwriting an existing function
-			addTo[name] = isFunction(val) && 
-							  isFunction(base[name]) && 
-							  fnTest.test(val) ? (function( name, fn ) {
-					return function() {
-						var tmp = this._super,
-							ret;
 
-						// Add a new ._super() method that is the same method
-						// but on the super-class
-						this._super = base[name];
+	// overwrites a single property so it can still call super
+	can.Construct._overwrite = function (addTo, base, name, val) {
+		// Check if we're overwriting an existing function
+		addTo[name] = isFunction(val) && isFunction(base[name]) && fnTest.test(val) ? (function (name, fn) {
+			return function () {
+				var tmp = this._super,
+					ret;
 
-						// The method only need to be bound temporarily, so we
-						// remove it when we're done executing
-						ret = fn.apply(this, arguments);
-						this._super = tmp;
-						return ret;
-					};
-				})(name, val) : val;
-		}
-		// overwrites an object with methods, sets up _super
-		//   newProps - new properties
-		//   oldProps - where the old properties might be
-		//   addTo - what we are adding to
-		can.Construct._inherit = function( newProps, oldProps, addTo ) {
-			addTo = addTo || newProps
-			for ( var name in newProps ) {
-				can.Construct._overwrite(addTo, oldProps, name, newProps[name]);
-			}
+				// Add a new ._super() method that is the same method
+				// but on the super-class
+				this._super = base[name];
+
+				// The method only need to be bound temporarily, so we
+				// remove it when we're done executing
+				ret = fn.apply(this, arguments);
+				this._super = tmp;
+				return ret;
+			};
+		})(name, val) : val;
+	}
+	// overwrites an object with methods, sets up _super
+	//   newProps - new properties
+	//   oldProps - where the old properties might be
+	//   addTo - what we are adding to
+	can.Construct._inherit = function (newProps, oldProps, addTo) {
+		addTo = addTo || newProps
+		for (var name in newProps) {
+			can.Construct._overwrite(addTo, oldProps, name, newProps[name]);
 		}
+	}
 
 
-})(this.can, this )
+})(can, this);

data/vendor/assets/javascripts/can.control.plugin.js

@@ -1,245 +1,108 @@
-(function(can, window, undefined){
-	
-
-
-//used to determine if a control instance is one of controllers
-//controllers can be strings or classes
-var i, 
-	isAControllerOf = function( instance, controllers ) {
-		for ( i = 0; i < controllers.length; i++ ) {
-			if ( typeof controllers[i] == 'string' ? instance.constructor._shortName == controllers[i] : instance instanceof controllers[i] ) {
+/*
+* CanJS - 1.1.2 (2012-11-28)
+* http://canjs.us/
+* Copyright (c) 2012 Bitovi
+* Licensed MIT
+*/
+(function (window, $, can, undefined) {
+	// ## can/control/plugin/plugin.js
+	//used to determine if a control instance is one of controllers
+	//controllers can be strings or classes
+	var i, isAControllerOf = function (instance, controllers) {
+		for (i = 0; i < controllers.length; i++) {
+			if (typeof controllers[i] == 'string' ? instance.constructor._shortName == controllers[i] : instance instanceof controllers[i]) {
 				return true;
 			}
 		}
 		return false;
 	},
-	data = function(el, data){
-		return $el.data('controls');
-	},
-	makeArray = can.makeArray,
-	old = can.Control.setup;
+		makeArray = can.makeArray,
+		old = can.Control.setup;
 
-/*
- * static
- */
-can.Control.setup = function() {
-	// if you didn't provide a name, or are control, don't do anything
-	if ( this !== can.Control ) {
-
-		/**
-		 * @attribute can.Control.plugin.static.pluginName
-		 * @parent can.Control.plugin
-		 *
-		 * Setting the static `pluginName` property allows you to override the default name
-		 * with your own.
-		 *
-		 *		var Filler = can.Control({
-		 *		  pluginName: 'fillWith'
-		 *		},{});
-		 * 
-		 *		$("#foo").fillWith();
-		 *
-		 * If you don't provide a `pluginName`, the control falls back to the
-		 * [can.Construct.fullName fullName] attribute:
-		 *
-		 *		can.Control('Ui.Layout.FillWith', {}, {});
-		 *		$("#foo").ui_layout_fill_with();
-		 *
-		 */
-		var pluginName = this.pluginName || this._fullName;
-			
-		// create jQuery plugin
-		if(pluginName !== 'can_control'){
-			this.plugin(pluginName);
-		}
-			
-		old.apply(this, arguments);
-	}
-};
+	can.Control.setup = function () {
+		// if you didn't provide a name, or are control, don't do anything
+		if (this !== can.Control) {
 
-/*
- * prototype
- */
-$.fn.extend({
-
-	/**
-	 * @function jQuery.fn.controls
-	 * @parent can.Control.plugin
-	 * 
-	 * When the widget is initialized, the plugin control creates an array 
-	 * of control instance(s) with the DOM element it was initialized on using 
-	 * [can.data] method.
-	 *
-	 * The `controls` method allows you to get the control instance(s) for any element.  
-	 *
-	 *		//- Inits the widgets
-	 *		$('.widgets:eq(0)').my_box();
-	 *		$('.widgets:eq(1)').my_clock();
-	 *
-	 *		<div class="widgets my_box" />
-	 *		<div class="widgets my_clock" />
-	 *
-	 *		$('.widgets').controls() //-> [ MyBox, MyClock ]
-	 *
-	 * Additionally, you can invoke it passing the name of a control
-	 * to fetch a specific instance(s).
-	 *
-	 *		//- Inits the widgets
-	 *		$('.widgets:eq(0)').my_box();
-	 *		$('.widgets:eq(1)').my_clock();
-	 *
-	 *		<div class="widgets my_box" />
-	 *		<div class="widgets my_clock" />
-	 *
-	 *		$('.widgets').controls('MyBox') //-> [ MyBox ]
-	 *
-	 * @param {Object} control (optional) if exists the control instance(s) with that constructor function or type will be returned.
-	 * @return {Array} an array of control instance(s).
-	 */
-	controls: function() {
-		var controllerNames = makeArray(arguments),
-			instances = [],
-			controls, c, cname;
-		//check if arguments
-		this.each(function() {
-
-			controls = can.$(this).data("controls");
-			if(!controls){
-				return;
+
+			var pluginName = this.pluginName || this._fullName;
+
+			// create jQuery plugin
+			if (pluginName !== 'can_control') {
+				this.plugin(pluginName);
 			}
-			for(var i=0; i<controls.length; i++){
-				c = controls[i];
-				if (!controllerNames.length || isAControllerOf(c, controllerNames) ) {
-					instances.push(c);
+
+			old.apply(this, arguments);
+		}
+	};
+
+	$.fn.extend({
+
+
+		controls: function () {
+			var controllerNames = makeArray(arguments),
+				instances = [],
+				controls, c, cname;
+			//check if arguments
+			this.each(function () {
+
+				controls = can.$(this).data("controls");
+				if (!controls) {
+					return;
 				}
-			}
-		});
-		return instances;
-	},
-	
-	/**
-	 * @function jQuery.fn.control
-	 * @parent can.Control.plugin
-	 * 
-	 * The `control` does the same as [jQuery.fn.controls controls] execept it only 
-	 * returns the first instance found.
-	 *
-	 *		//- Init MyBox widget
-	 *		$('.widgets').my_box();
-	 *
-	 *		<div class="widgets my_box" />
-	 *
-	 *		$('.widgets').controls() //-> MyBox
-	 *
-	 * @param {Object} control (optional) if exists the first control instance with that constructor function or type will be returned.
-	 * @return {can.Control} the first control.
-	 */
-	control: function( control ) {
-		return this.controls.apply(this, arguments)[0];
-	}
-});
-
-can.Control.plugin = function(pluginname){
-	var control = this;
-
-	if (!$.fn[pluginname]) {
-		$.fn[pluginname] = function(options){
-		
-			var args = makeArray(arguments),   //if the arg is a method on this control
-			isMethod = typeof options == "string" && $.isFunction(control.prototype[options]), meth = args[0];
-			return this.each(function(){
-				//check if created
-				var plugin = can.$(this).control(control);
-				
-				if (plugin) {
-					if (isMethod) {
-						// call a method on the control with the remaining args
-						plugin[meth].apply(plugin, args.slice(1));
+				for (var i = 0; i < controls.length; i++) {
+					c = controls[i];
+					if (!controllerNames.length || isAControllerOf(c, controllerNames)) {
+						instances.push(c);
 					}
-					else {
-						// call the plugin's update method
-						plugin.update.apply(plugin, args);
-					}
-				}
-				else {
-					//create a new control instance
-					control.newInstance.apply(control, [this].concat(args));
 				}
 			});
-		};
+			return instances;
+		},
+
+
+		control: function (control) {
+			return this.controls.apply(this, arguments)[0];
+		}
+	});
+
+	can.Control.plugin = function (pluginname) {
+		var control = this;
+
+		if (!$.fn[pluginname]) {
+			$.fn[pluginname] = function (options) {
+
+				var args = makeArray(arguments),
+					//if the arg is a method on this control
+					isMethod = typeof options == "string" && $.isFunction(control.prototype[options]),
+					meth = args[0],
+					returns;
+				this.each(function () {
+					//check if created
+					var plugin = can.$(this).control(control);
+
+					if (plugin) {
+						if (isMethod) {
+							// call a method on the control with the remaining args
+							returns = plugin[meth].apply(plugin, args.slice(1));
+						}
+						else {
+							// call the plugin's update method
+							plugin.update.apply(plugin, args);
+						}
+					}
+					else {
+						//create a new control instance
+						control.newInstance.apply(control, [this].concat(args));
+					}
+				});
+				return returns !== undefined ? returns : this;
+			};
+		}
 	}
-}
-
-/**
- * @function can.Control.prototype.update
- * @parent can.Control.plugin
- * 
- * Update extends [can.Control.prototype.options options] 
- * with the `options` argument and rebinds all events.  It 
- * re-configures the control.
- * 
- * For example, the following control wraps a recipe form. When the form
- * is submitted, it creates the recipe on the server.  When the recipe
- * is `created`, it resets the form with a new instance.
- * 
- *		var Creator = can.Control({
- *		  "{recipe} created" : function(){
- *		    this.update({recipe : new Recipe()});
- *		    this.element[0].reset();
- *		    this.element.find("[type=submit]").val("Create Recipe")
- *		  },
- *		  "submit" : function(el, ev){
- *		    ev.preventDefault();
- *		    var recipe = this.options.recipe;
- *			recipe.attrs( this.element.formParams() );
- *			this.element.find("[type=submit]").val("Saving...")
- *			recipe.save();
- *		  }
- *		});
- *
- *		$('#createRecipes').creator({ recipe : new Recipe() })
- * 
- * *Update* is called if a control's plugin helper is called with the plugin options on an element
- * that already has a control instance of the same type. If you want to implement your
- * own update method make sure to call the old one either using the [can.Construct.super super] plugin or
- * by calling `can.Control.prototype.update.apply(this, arguments);`.
- * For example, you can change the content of the control element every time the options change:
- * 
- *		var Plugin = can.Control({
- *		    pluginName: 'myPlugin'
- *		  }, {
- *		    init : function(el, options) {
- *			  this.updateCount = 0;
- *			  this.update({
- *			    text : 'Initialized'
- *			  });
- *			},
- *			update : function(options) {
- *			  // Call the can.Control update first.
- *			  // Use this._super when using can/construct/super
- *			  can.Control.prototype.update.call(this, options);
- *			  this.element.html(this.options.text + ' ' +
- *			    (++this.updateCount) + ' times');
- *			}
- *		});
- *
- *		$('#control').myPlugin();
- *		$('#control').html();
- *		// Initialized. Updated 1 times
- *
- *		$('#control').myPlugin({ text : 'Calling update. Updated' });
- *		$('#control').html();
- *		// Calling update. Updated 2 times
- *
- * @demo can/control/plugin/demo-update.html
- * 
- * @param {Object} options A list of options to merge with 
- * [can.Control.prototype.options this.options].  Often this method
- * is called by the [can.Control.plugin jQuery helper function].
- */
-can.Control.prototype.update = function( options ) {
+
+	can.Control.prototype.update = function (options) {
 		can.extend(this.options, options);
 		this.on();
-};
+	};
 
-})(this.can, this )
+})(this, jQuery, can);