canjs-rails 0.1.0

data/.gitignore

@@ -0,0 +1,7 @@
+pkg/*
+tmp
+spec/support/*/Gemfile.lock
+spec/support/*/public/javascripts
+.rvmrc
+.bundle
+imports/*

data/CHANGELOG.md

@@ -0,0 +1,3 @@
+## 0.1.0 (26 June 2012)
+
+- initial release

data/Gemfile

@@ -0,0 +1,3 @@
+source :rubygems
+
+gemspec

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License
+
+Copyright (c) 2012 Craig Wickesser
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,36 @@
+# canjs-rails
+
+CanJS for Rails!
+
+This gem provides:
+
+  * can.jquery 1.0.7 (and can.jquery.min)
+  * all can.js plugins available as of CanJS 1.0.7
+
+This gem requires the asset pipeline, so it should work with Rails 3.1 or later. The version of CanJS included with this gem (can.jquery) requires jQuery, conveniently Rails 3.1 and later includes jquery-rails by default, so you won't need to explicitly install jQuery. However, if you aren't using jquery-rails make sure you install jQuery and require it before can.jquery in your `app/assets/javascripts/application.js`.
+
+## Installation
+
+Add the canjs-rails gem to your Gemfile.
+
+```ruby
+gem "canjs-rails"
+```
+
+And run `bundle install`. 
+
+### Rails 3.1 or greater (with asset pipeline *enabled*)
+
+To make the core CanJS library available add these lines to `app/assets/javascripts/application.js`:
+
+```js
+//= require can.jquery
+```
+
+You're done!
+
+## Acknowledgements
+
+Many thanks are due to [the jquery-rails project](https://github.com/rails/jquery-rails/) as it was used as the basis for this gem.
+
+Copyright [Craig Wickesser](http://mindscratch.org), released under the MIT License.

data/Rakefile

@@ -0,0 +1,2 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks

data/canjs-rails.gemspec

@@ -0,0 +1,23 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/canjs/rails/version', __FILE__)
+
+Gem::Specification.new do |s|
+  s.name        = "canjs-rails"
+  s.version     = Canjs::Rails::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Craig Wickesser"]
+  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.required_rubygems_version = ">= 1.3.6"
+  s.rubyforge_project         = "canjs-rails"
+
+  s.add_dependency "railties", ">= 3.2.0", "< 5.0"
+  s.add_dependency "thor",     "~> 0.14"
+
+  s.files        = `git ls-files`.split("\n")
+  s.executables  = `git ls-files -- bin/*`.split("\n").map { |f| File.basename(f) }
+  s.require_path = 'lib'
+end

data/lib/canjs-rails.rb

@@ -0,0 +1 @@
+require 'canjs/rails'

data/lib/canjs/rails.rb

@@ -0,0 +1,7 @@
+require 'canjs/rails/engine'
+require 'canjs/rails/version'
+
+module Canjs
+  module Rails
+  end
+end

data/lib/canjs/rails/engine.rb

@@ -0,0 +1,6 @@
+module Canjs
+  module Rails
+    class Engine < ::Rails::Engine
+    end
+  end
+end

data/lib/canjs/rails/version.rb

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

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

@@ -0,0 +1,60 @@
+(function(can, window, undefined){
+var isFunction = can.isFunction,
+	isArray = can.isArray,
+	makeArray = can.makeArray,
+
+proxy = function( funcs ) {
+
+			//args that should be curried
+			var args = makeArray(arguments),
+				self;
+
+			// get the functions to callback
+			funcs = args.shift();
+
+			// if there is only one function, make funcs into an array
+			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,
+					f = 0,
+					func;
+				
+				// go through each function to call back
+				for (; f < length; f++ ) {
+					func = funcs[f];
+					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 ) {
+						cur = !isArray(cur) || cur._use_call ? [cur] : cur
+					}
+				}
+				return cur;
+			}
+		}
+	can.Construct.proxy = can.Construct.prototype.proxy = proxy;
+	
+	
+
+
+
+
+})(this.can, this )

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

@@ -0,0 +1,44 @@
+(function(can, window, undefined){
+
+// tests if we can get super in .toString()
+	var isFunction = can.isFunction,
+		
+		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];
+
+						// 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 )

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

@@ -0,0 +1,245 @@
+(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] ) {
+				return true;
+			}
+		}
+		return false;
+	},
+	data = function(el, data){
+		return $el.data('controls');
+	},
+	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);
+	}
+};
+
+/*
+ * 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;
+			}
+			for(var i=0; i<controls.length; i++){
+				c = controls[i];
+				if (!controllerNames.length || isAControllerOf(c, controllerNames) ) {
+					instances.push(c);
+				}
+			}
+		});
+		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));
+					}
+					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));
+				}
+			});
+		};
+	}
+}
+
+/**
+ * @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.extend(this.options, options);
+		this.on();
+};
+
+})(this.can, this )