kojac 0.9.0

data/app/assets/javascripts/kojac_canjs.js

@@ -0,0 +1,191 @@
+/*--------------------------------------------------------------------------
+ *
+ *	Key Oriented JSON Application Cache (KOJAC)
+ *	(c) 2011-12 Buzzware Solutions
+ *  https://github.com/buzzware/KOJAC
+ *
+ *	KOJAC is freely distributable under the terms of an MIT-style license.
+ *
+ *--------------------------------------------------------------------------*/
+(function() {
+
+// minimal plugin example
+//(function(can, window, undefined){
+//	var oldSetup = can.Observe.setup;
+//	can.extend(can.Observe, {
+//		setup : function(superClass){
+//			oldSetup.apply(this, arguments);
+//		}
+//	});
+//
+////		can.extend(can.Observe.prototype, {
+////		});
+//
+//})(this.can, this );
+
+	MODEL_FIELD_CONVERTERS = { // these are only used when you call .serialize()
+		'Int' : function( aValue ){
+			return Kojac.interpretValueAsType(aValue,Int);
+		},
+		'Number' : function( aValue ){
+			return Kojac.interpretValueAsType(aValue,Number);
+		},
+		'String' : function( aValue ){
+			return Kojac.interpretValueAsType(aValue,String);
+		},
+		'Boolean' : function( aValue ){
+			return Kojac.interpretValueAsType(aValue,Boolean);
+		},
+		'Date' : function( aValue ){
+			return Kojac.interpretValueAsType(aValue,Date);
+		},
+		'Array' : function( aValue ){
+			return Kojac.interpretValueAsType(aValue,Array);
+		},
+		'Object' : function( aValue ){
+			return Kojac.interpretValueAsType(aValue,Object);
+		}
+	};
+
+	Kojac.CanModel = can.Observe({
+		fullName: 'Kojac.CanModel',
+		extend: function(aFullName, aClass, aInstanceProps) {
+			if ( typeof aFullName != 'string' ) {
+				aInstanceProps = aClass;
+				aClass = aFullName;
+				aFullName = null;
+			}
+			if ( ! aInstanceProps ) {
+				aInstanceProps = aClass;
+				aClass = null;
+			}
+			aInstanceProps = aInstanceProps || {};
+			aClass = aClass || {};
+
+			if (aClass && (('attributes' in aClass) || ('defaults' in aClass) || ('serialize' in aClass) || ('convert' in aClass)))
+				throw new Error('attributes, defaults, serialize and convert not supported');
+
+			var attributes = {};
+			var defaults = {};
+			for (var p in aInstanceProps) {
+				var v = aInstanceProps[p];
+				var i = Kojac.FieldTypes.indexOf(v);
+				if (i >= 0) {   // field type
+					v = null;
+					defaults[p] = v;
+					attributes[p] = Kojac.FieldTypeStrings[i];
+					delete aInstanceProps[p];
+				} else if (_.isFunction(v)) {   // a method
+					// don't touch this
+				} else {        // default value
+					i = Kojac.FieldTypes.indexOf(Kojac.getPropertyValueType(v));
+					if (i >= 0) {
+						attributes[p] = Kojac.FieldTypeStrings[i];
+						defaults[p] = v;
+					}
+					delete aInstanceProps[p];
+				}
+			}
+			_.extend(aClass,{
+				attributes: attributes,
+				defaults: defaults,
+				serialize : MODEL_FIELD_CONVERTERS, // these are only used when you call .serialize()
+				convert: MODEL_FIELD_CONVERTERS    // these are only used when you set properties with attr
+			});
+			if (aFullName)
+				return can.Observe.extend.apply(this, [aFullName,aClass,aInstanceProps]);
+			else
+				return can.Observe.extend.apply(this, [aClass,aInstanceProps]);
+		}
+	},{
+	});
+
+	Kojac.CanObjectFactory = Kojac.ObjectFactory.extend({
+
+		defaultClass: can.Observe,
+
+		copyProperties: function(aDest,aSource) {
+			return CanUtils.copyProperties(aDest,aSource);
+		}
+
+	});
+
+
+	Kojac.CanCache = can.Observe({
+//	convert: {
+//		default: function(aValue) { return aValue; }
+//	}
+},{
+
+//	__convert: function(prop, value){
+//		console.log('__convert');
+//		return value;
+//	},
+
+	get: function(k) {
+		return this.attr(k);
+	},
+	set: function(k,v) {
+		return this.attr(k,v);
+	},
+
+	cacheResults: function(aRequest) {
+		console.log('BEGIN cacheResults')
+		var results = {};
+		var deletes = [];
+		for (var i=0;i<aRequest.ops.length;i++) {
+			var op = aRequest.ops[i];
+			if (op.error)
+				break;
+			if (op.options.cacheResults===false)
+				continue;
+			for (p in op.results) {
+				var v = op.results[p];
+				results[p] = v;
+				if (v===undefined)
+					deletes.push(p);
+				else
+					deletes = _.without(deletes, [p]);
+			}
+		}
+		for (p in results) {
+			try {
+				this.attr(p,results[p]);
+			} catch (e) {
+				console.log('Error when caching '+p+' : '+ e.message);
+			}
+		}
+//		if (deletes.length) {
+//			for (var i=0;i<deletes.length;i++) {
+//				console.log('cacheResults remove');
+//				this.removeAttr(deletes[i]);
+//			}
+//		}
+		console.log('END cacheResults');
+	},
+
+	collectIds: function(aPrefix, aIds) {
+		return Kojac.collectIds(aPrefix,aIds,this);
+	},
+
+	collectionValues: function(aCollectionKey) {
+		return Kojac.collectionValues(aCollectionKey,this);
+	}
+
+});
+
+Kojac.collectIds = function(aPrefix,aIds,aCache) {
+	if (!aIds)
+		return [];
+	var result = [];
+	for (var i=0;i<aIds.length;i++)
+		result.push(aCache.get(aPrefix+'__'+aIds[i]));
+	return result;
+};
+
+Kojac.collectionValues = function(aCollectionKey,aCache) {
+	var ids = aCache.get(aCollectionKey);
+	return Kojac.collectIds(aCollectionKey,ids,aCache);
+};
+
+})();

data/app/assets/javascripts/kojac_ember.js

@@ -0,0 +1,463 @@
+/*--------------------------------------------------------------------------
+ *
+ *	Key Oriented JSON Application Cache (KOJAC)
+ *	(c) 2011-12 Buzzware Solutions
+ *  https://github.com/buzzware/KOJAC
+ *
+ *	KOJAC is freely distributable under the terms of an MIT-style license.
+ *
+ *--------------------------------------------------------------------------*/
+
+// recommended http://www.cerebris.com/blog/2012/03/06/understanding-ember-object/
+//var Person = Ember.Object.extend({
+//	chromosomes: null,
+//	init: function() {
+//		this._super();
+//		this.chromosomes = ["x"]; // everyone gets at least one X chromosome
+//	}
+//});
+
+// declaring property : {chromosomes: null}
+// for values, generate function that calls this._super(); then loops thru setting values
+
+// example :
+//
+//Product = Kojac.EmberModel.extend({
+//	name: String,
+//	purchases: Int,
+//	weight: Number,
+//	isMember: Boolean,
+//	init: function() {
+//		this._super();
+//		this.weight = 0.0;
+//	}
+//});
+//
+//
+// 1. Create extendObject with properties: null
+// 2.
+
+
+Kojac.EmberObjectFactory = Kojac.Object.extend({
+
+	matchers: null,
+
+	register: function(aPairs) {
+		if (!aPairs)
+			return;
+		if (this.matchers===null)
+			this.matchers = [];
+		for (var i = 0; i < aPairs.length; i++)
+			this.matchers.push(aPairs[i]);
+	},
+
+	emberClassFromKey: function(aKey) {
+		var pair;
+		var re;
+		var newClass;
+		for (var i = 0; i < this.matchers.length; i++) {
+			pair = this.matchers[i];
+			re = pair[0];
+			if (!re.test(aKey))
+				continue;
+			newClass = pair[1];
+			break;
+		}
+		if (newClass===undefined)
+			newClass = Ember.Object;
+		return newClass;
+	},
+
+	emberObjectFactoryArray: function(aArray,aKey) {
+		var newClass = this.emberClassFromKey(aKey);
+		var result = [];
+		for (var i=0; i<aArray.length; i++) {
+			var newv = new newClass();
+			newv.setProperties(aArray[i]);
+			result.push(newv);
+		}
+		return result;
+	},
+
+	emberObjectFactory: function(aObject,aKey) {
+		var newClass = this.emberClassFromKey(aKey);
+		var newv = new newClass();
+		newv.setProperties(aObject);
+		return newv;
+	},
+
+	transformResultsToValueObjects: function(aRequest) {
+		for (var i=0;i<aRequest.ops.length;i++) {
+			var op = aRequest.ops[i];
+			if (op.error)
+				break;
+			for (var k in op.results) {
+				var v = op.results[k];
+				if (!jQuery.isPlainObject(v))
+					continue;
+				op.results[k] = this.emberObjectFactory(v,k);
+			}
+		}
+	}
+
+});
+
+
+
+//ExampleRemoteProvider = Ember.Object.extend({
+//Kojac.RemoteProvider = Kojac.Object.extend({
+//
+//	useMockFileValues: false,
+//  mockFilePath: '',
+//	mockReadOperationHandler: null,
+//	mockWriteOperationHandler: function(aOp) {
+//		log.debug(JSON.stringify(EmberUtils.copyProperties({},aOp,null,['request'])));
+//	},
+//
+//	handleOperationFromFiles: function(aRequest) {
+//		var op = aRequest.handlers.parameter;
+//
+//		if (op.verb==='READ' || op.verb==='EXECUTE') {
+//			if (this.mockReadOperationHandler) {
+//				this.mockReadOperationHandler(op);
+//			} else {
+//				aRequest.handlers.waitForCallNext = true;
+//				var fp = mockFilePath+op.key+'.js';
+//				var data = null;
+//				jQuery.ajax({url: fp, dataType: 'json', cache: false, data: data}).done(
+//					function( aData ) {
+//						for (p in aData)
+//							op[p] = aData[p];
+//						aRequest.handlers.callNext();
+//					}
+//				).fail(
+//					function(jqXHR, textStatus) {
+//						aRequest.handlers.handleError(textStatus);
+//					}
+//				);
+//			}
+//		} else {
+//			if (this.mockWriteOperationHandler)
+//				this.mockWriteOperationHandler(op);
+//		}
+//	},
+//
+//	handleAjaxRequest: function(aRequest) {
+//		var op = aRequest.parameter;
+//		aRequest.handlers.waitForCallNext = true;
+//		jQuery.ajax({},function(){
+//			aRequest.handlers.callNext();
+//		})
+//	},
+//
+//	addRequestHandlers: function(aRequest) {
+//		if (this.useMockFileValues) {
+//			for (var i=0;i<aRequest.ops.length;i++)
+//				aRequest.handlers.add(this.handleOperationFromFiles,aRequest.ops[i],this);
+//		} else {
+//			aRequest.handlers.add(this.handleAjaxRequest,null,this);
+//		}
+//	}
+//
+//});
+
+
+Kojac.EmberModel = Ember.Object.extend({});
+
+Kojac.EmberModel.reopenClass({
+
+	//_extend: Ember.Object.extend,
+
+	extend: function() {
+		var defs = arguments[0];
+		var extender = {};
+		var definitions = this.getDefinitions();
+		var defaults = this.getDefaults();
+		var _type;
+		var _value;
+		//var _init;
+		if (defs) {
+			for (p in defs) {
+				var pValue = defs[p];
+//				if (p=='init') {
+//					_init = pValue;
+//				} else {
+					if (Kojac.FieldTypes.indexOf(pValue)>=0) { // pValue is field type
+						definitions[p] = pValue;
+						defaults[p] = null;
+						extender[p] = null;
+					} else {
+						var ft=Kojac.getPropertyValueType(pValue);
+						if (ft && (Kojac.SimpleTypes.indexOf(ft)>=0)) {  // pValue is simple field value
+							definitions[p] = ft;
+							defaults[p] = pValue;
+							extender[p] = pValue;
+						} else {  // pValue is something else
+							//definitions[p] = _type;
+							//defaults[p] = _value;
+							extender[p] = pValue;
+						}
+					}
+	//			}
+			}
+//			extender.init = function() {  // we need to call the super init, then initialise default values, then call the given init
+//				this._super();
+//				//var defaults = this.constructor.getDefaults();
+//				//for (dp in defaults)
+//				//	this[dp] = defaults[dp];
+//				if (_init) {
+//					var _super = this._super;
+//					this._super = function() {};  // temporarily disable _super to make init function work like normal ember init
+//					_init.call(this);
+//					if (_super)
+//						this._super = _super;       // restore _super
+//				}
+//			};
+		}
+		var result = this._super(extender);
+		result.setDefinitions(definitions);
+		result.setDefaults(defaults);
+		return result;
+	},
+
+	setDefinitions: function(aDefinitions) {
+		this._definitions = (aDefinitions || {});
+	},
+
+	getDefinitions: function() {
+		return this._definitions || {};
+	},
+
+	setDefaults: function(aDefaults) {
+		this._defaults = (aDefaults || {});
+	},
+
+	getDefaults: function() {
+		return this._defaults || {};
+	},
+
+	__createWithMixins: Kojac.EmberModel.createWithMixins,
+	createWithMixins: function() {
+		var inputs = arguments;
+		if (inputs.length) {
+			inputs[0] = Kojac.readTypedProperties({},inputs[0],this.getDefinitions());
+		}
+		return this.__createWithMixins.apply(this,inputs);
+  },
+
+	__create: Kojac.EmberModel.create,
+	create: function() {
+		var inputs = arguments;
+		if (inputs.length) {
+			inputs[0] = Kojac.readTypedProperties({},inputs[0],this.getDefinitions());
+		}
+		return this.__create.apply(this,inputs);
+	}
+
+});
+
+Kojac.EmberModel.reopen({
+
+	___set: Ember.set,
+	set: function(k,v) {
+		var def = this.constructor.getDefinitions();
+		var t = (def && def[k]);
+		if (t)
+			v = Kojac.interpretValueAsType(v,t);
+		return this.___set(this,k,v);
+	},
+
+	___setProperties: Ember.setProperties,
+	setProperties: function(values) {
+		values = Kojac.readTypedProperties({},values,this.constructor.getDefinitions());
+		return this.___setProperties(this,values);
+	},
+
+	toObject: function(aOptions) {
+		var result = {};
+		var defs = this.constructor.getDefinitions();
+		var includes = aOptions && aOptions.include
+		for (var p in defs)
+			result[p] = this.get(p);
+		if (includes) {
+			includes = this.getProperties(includes);
+			var v;
+			for (var p in includes) {
+				v = includes[p];
+				if (v && (typeof(v)=="object") && ("toObject" in v))
+					includes[p] = v.toObject();
+			}
+			_.extend(result,includes);
+		}
+		return result;
+	}
+
+});
+
+
+Kojac.EmberCache = Ember.Object.extend({
+
+	generateKey: function(aPrefix) {
+		var key;
+		do {
+			key = aPrefix+'__'+(-_.random(1000000,2000000)).toString();
+		} while (key in this);
+		return key;
+	},
+
+	generateId: function(aPrefix) {
+		var key;
+		var id;
+		do {
+			id = -_.random(1000000,2000000)
+			key = aPrefix+'__'+id.toString();
+		} while (key in this);
+		return id;
+	},
+
+	store: function(aKeysValues) {
+		this.beginPropertyChanges();
+		for (p in aKeysValues) {
+			if (aKeysValues[p]===undefined) {
+				this.set(p,undefined);
+				delete this[p];
+			} else {
+				this.set(p,aKeysValues[p]);
+			}
+		}
+		this.endPropertyChanges();
+	},
+
+	cacheResults: function(aRequest) {
+		this.beginPropertyChanges();
+		for (var i=0;i<aRequest.ops.length;i++) {
+			var op = aRequest.ops[i];
+			if (op.error)
+				break;
+			if (op.options.cacheResults===false)
+				continue;
+			this.store(op.results);
+		}
+		this.endPropertyChanges();
+	},
+
+	collectIds: function(aPrefix, aIds) {
+		return Kojac.collectIds(aPrefix,aIds,this);
+	}
+
+});
+
+Kojac.collectIds = function(aPrefix,aIds,aCache,aFilterFn) {
+	if (!aIds)
+		return [];
+	var result = [];
+	var item;
+	for (var i=0;i<aIds.length;i++) {
+		item = aCache.get(aPrefix+'__'+aIds[i]);
+		if (!aFilterFn || aFilterFn(item))
+			result.push(item);
+	}
+	return result;
+};
+
+Ember.computed.collectIds = function(aCollectionProperty,aPrefix,aModelCachePath,aFilterFn){
+	if (!aPrefix)
+		aPrefix = _.last(aCollectionProperty.split('.'));
+
+  return Ember.computed(aCollectionProperty, function(){
+	  var cache;
+	  if (aModelCachePath)
+	    cache = Ember.Handlebars.get(this,aModelCachePath);  //(aModelCachePath && Ember.get(aModelCachePath));
+	  else
+		  cache = this;
+	  var ids = Ember.Handlebars.get(this,aCollectionProperty);
+	  if (!ids)
+	 		return [];
+	 	var result = [];
+	 	var item;
+	 	for (var i=0;i<ids.length;i++) {
+	 		item = cache.get(aPrefix+'__'+ids[i]);
+	 		if (!aFilterFn || aFilterFn(item))
+	 			result.push(item);
+	 	}
+	 	return result;
+  }).property(aModelCachePath,aCollectionProperty);
+};
+
+Ember.computed.has_many = function(aResource,aForeignKey,aLocalPropertyPath,aModelCachePath,aFilterFn){
+
+  return Ember.computed(function(){
+	  var cache;
+	  if (aModelCachePath)
+	    cache = Ember.Handlebars.get(this,aModelCachePath);  //(aModelCachePath && Ember.get(aModelCachePath));
+	  else
+		  cache = this;
+	  var localValue = Ember.Handlebars.get(this,aLocalPropertyPath);
+
+	  if (!_.endsWith(aResource,'__'))
+	    aResource = aResource+'__';
+
+	  var results = [];
+	  // get all keys that begin with aPrefix
+	  var keys = _.keys(cache);
+	  for (var i=0;i<keys.length;i++) {
+		  var k = keys[i];
+		  if (!_.beginsWith(k,aResource))
+		    continue;
+		  var v = cache.get(k);
+		  if (!v || (v.get(aForeignKey) != localValue))
+			  continue;
+		  if (aFilterFn && !aFilterFn(k,v))
+		    continue;
+		  results.push(v);
+	  }
+	 	return results;
+  }).property(aModelCachePath,aLocalPropertyPath);
+};
+
+Ember.computed.modelById = function(aIdProperty,aPrefix,aModelCachePath) {
+	if (!aModelCachePath)
+		aModelCachePath = 'App.cache';
+
+	return Ember.computed(aIdProperty, function(){
+		var id = Ember.Handlebars.get(this,aIdProperty);
+		if (!id)
+			return null;
+		var cache = Ember.Handlebars.get(this,aModelCachePath);
+		var key = keyJoin(aPrefix,id);
+		if (!key || !cache)
+			return null;
+		return Ember.Handlebars.get(cache,key);
+	}).property(aModelCachePath,aIdProperty);
+};
+
+Ember.computed.modelByIdVersioned = function(aIdProperty,aVerProperty,aPrefix,aModelCachePath) {
+	if (!aModelCachePath)
+		aModelCachePath = 'App.cache';
+
+	return Ember.computed(aIdProperty, function(){
+		var id = Ember.Handlebars.get(this,aIdProperty);
+		var cache = Ember.Handlebars.get(this,aModelCachePath);
+		if (!id || !cache)
+			return null;
+		var key;
+		var ver = Ember.Handlebars.get(this,aVerProperty);
+		if (ver) {
+			id = [id,ver].join('_');
+			key = keyJoin(aPrefix,id);
+			return Ember.Handlebars.get(cache,key);
+		} else {
+			var versions = _.pickWithPrefix(cache,keyJoin(aPrefix,id)+'_');
+			var v,vi;
+			key = _.max(_.keys(versions), function(k){
+				vi = k.lastIndexOf('_');
+				return Number(k.substr(vi+1));
+			});
+			return key ? versions[key] : null;
+		}
+	}).property(aModelCachePath,aIdProperty,aVerProperty);
+};
+
+
+
+

data/app/controllers/kojac_controller.rb

@@ -0,0 +1,70 @@
+class KojacController < ApplicationController
+
+	respond_to :json
+	protect_from_forgery :only => []
+
+	protected
+
+	def controller_for_key(aKey)
+		resource = aKey.split('__').first
+		controller_name = resource.camelize+'Controller'
+		if controller = controller_name.constantize
+			result = controller.new
+			result.current_user = self.current_user
+			result
+		else
+			nil
+		end
+	end
+
+	def process_ops(aInput)
+		result = { }
+		if ops = aInput[:ops]
+			result[:ops] = []
+			ops.each do |op|
+				method = "#{op[:verb].to_s.downcase}_op".to_sym
+				ctrlr = self.controller_for_key(op[:key])
+				if ctrlr.respond_to? method
+					ctrlr.params = {op: op}
+					output = ctrlr.send method
+					result[:ops] << output
+				else
+					raise "Unsupported verb #{op[:verb]}"
+				end
+			end
+		end
+		result
+	end
+
+	public
+
+	def receive
+		input = nil
+		output = nil
+		status = :ok
+
+    begin
+      input = params[:kojac]
+      output = process_ops(input)
+			status = :ok
+    rescue => e
+			raise e unless Rails.env.production?
+			Rails.logger.debug e.message
+			Rails.logger.debug e.backtrace.join("\n")
+	    output = {
+		    results: nil,
+	      errors: [{
+		      message: e.message,
+	        backtrace: e.backtrace
+	      }]
+	    }
+			status = :unprocessable_entity
+    end
+    #output = ActiveModel::Serializer.new(output,current_user).to_json
+    #sz = output.active_model_serializer.new(output)
+    #jsons = sz.to_json(:scope => current_user, :root => false)
+    jsons = app_serialize(output,current_user)
+    render json: jsons, status: status
+	end
+
+end