kojac 0.11.0 → 0.12.0

data/app/assets/javascripts/kojac_ember.js

@@ -8,6 +8,29 @@
  *
  *--------------------------------------------------------------------------*/
 
+/* Ideas for future
+
+stop using ids in collections, use full key instead
+
+so then cache can be like :
+{
+	allProducts: ['product__1','product__2'],
+	product__1: {
+		name: 'red toy'
+	},
+	product__2: {
+		name: 'blue toy'
+	}
+	productCol: Emberjac.modelCollection(
+		'allProducts',    // idCollection property, potentially path eg. 'App.cache.allProducts'. Binds to this and its contents
+		function(aArray){
+			// optionally filter and/or sort array here, return result leaving original unmodified
+		}
+	)
+}
+
+ */
+
 // recommended http://www.cerebris.com/blog/2012/03/06/understanding-ember-object/
 //var Person = Ember.Object.extend({
 //	chromosomes: null,
@@ -38,231 +61,146 @@
 // 2.
 
 
-Kojac.EmberObjectFactory = Kojac.Object.extend({
+Kojac.EmberObjectFactory = Kojac.ObjectFactory.extend({
 
-	matchers: null,
+	defaultClass: Ember.Object,
 
-	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]);
-	},
+	createInstance: function(aClass,aProperties) {
+		aProperties = aProperties || {};
+		return aClass.create(aProperties);
+	}
 
-	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;
+});
+
+Kojac.EmberModel = Ember.Object.extend({
+
+//	set: function(k,v) {
+//		var def = this.constructor.getDefinitions();
+//		var t = (def && def[k]);
+//		if (t)
+//			v = Kojac.interpretValueAsType(v,t);
+//		return this._super(k,v);
+//	},
+//
+//	setProperties: function(values) {
+//		values = Kojac.readTypedProperties({},values,this.constructor.getDefinitions());
+//		return this._super(values);
+//	},
+
+	// copy the property from source to dest
+	// this could be a static fn
+	toJsonoCopyFn: function(aDest,aSource,aProperty,aOptions) {
+		aDest[aProperty] = Kojac.Utils.toJsono(Ember.get(aSource,aProperty),aOptions);
 	},
 
-	emberObjectFactoryArray: function(aArray,aKey) {
-		var newClass = this.emberClassFromKey(aKey);
-		var result = [];
-		for (var i=0; i<aArray.length; i++) {
-			var newv = newClass.create(aArray[i]);
-			result.push(newv);
+	// return array of names, or an object and all keys will be used
+	// this could be a static fn
+	toPropListFn: function(aSource,aOptions) {
+		var p;
+		if (p = aSource && aSource.constructor && aSource.constructor.proto && aSource.constructor.proto()) {
+			if ((p = Ember.meta(p)) && (p = p.descs)) {
+				var result = [];
+				var m;
+				var d;
+				var k;
+				var keys = _.keys(p);
+				for (var i=0;i<keys.length;i++) {
+					k = keys[i];
+					if (!(d = p[k]))
+						continue;
+					if (!(m = d.meta()))
+						continue;
+					if (m.kemp)
+						result.push(k);
+				}
+				return result;
+			} else
+				return [];
+		} else {
+			return aSource;
 		}
-		return result;
 	},
 
-	manufacture: function(aObject,aKey) {
-		var newClass = this.emberClassFromKey(aKey);
-		var newv = newClass.create(aObject);
-		return newv;
+	toJsono: function(aOptions) {
+		return Kojac.Utils.toJsono(this,aOptions,this.toPropListFn,this.toJsonoCopyFn)
 	}
 
 });
 
-Kojac.EmberModel = Ember.Object.extend({});
-
-Kojac.EmberModel.TypedField = function() {
-  this.get = function(obj,keyName) {    // Here code was copied from Ember get to avoid endless recursion. This is more efficient but brittle for future Ember versions
-	  var meta = Ember.meta(obj),
-		  desc = (meta && meta.descs[keyName]),
-		  ret;
-	  if (Ember.ENV.MANDATORY_SETTER && meta && (meta.watching[keyName] > 0)) {
-		  ret = meta.values[keyName];
-	  } else {
-		  ret = obj[keyName];
-	  }
-	  if ((ret === undefined) &&
-		  ('object' === typeof obj) && !(keyName in obj) && ('function' === typeof obj.unknownProperty)) {
-		  return obj.unknownProperty(keyName);
-	  }
-	  return ret;
-  }
-	this.set = function(obj,keyName,aValue) {   // here we call the standard method after removing the desc to prevent endless recursion, then put it back.
-		var result;
-		var def = obj.constructor.getDefinitions();
-		var t = (def && def[keyName]);
-		if (t)
-			aValue = Kojac.interpretValueAsType(aValue,t);
-		var meta = Ember.meta(obj),
-			desc = (meta && meta.descs[keyName]);
-		meta.descs[keyName] = undefined;
-		try {
-			result = Ember.set(obj,keyName,aValue);
-		}
-		finally {
-			meta.descs[keyName] = desc;
-		}
-		return result;
-	}
-};
-Kojac.EmberModel.TypedField.prototype = new Ember.Descriptor();
+// in create, set cache with defaults merged with given values
+// getter - use cacheFor
+// setter - set cache with converted value
+// in extend, generate with Ember.computed().cacheable(true)
+
+
+
 
 Kojac.EmberModel.reopenClass({
 
 	extend: function() {
 		var defs = arguments[0];
 		var extender = {};
-		var definitions = this.getDefinitions();
-		var defaults = this.getDefaults();
 
 		var _type;
 		var _value;
-		//var _init;
 		if (defs) {
+			var destType;
+			var defaultValue;
 			for (p in defs) {
 				var pValue = defs[p];
+				destType = null;
+				defaultValue = null;
+
 				if (Kojac.FieldTypes.indexOf(pValue)>=0) { // pValue is field type
-					definitions[p] = pValue;
-					defaults[p] = null;
-					extender[p] = null;
+					destType = pValue;
+					defaultValue = 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;
+						destType = ft;
+						defaultValue = pValue;
 					}
 				}
-			}
-		}
-		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 || {};
-	},
-
-	__addDescs: function(aNewInstance){
-		var meta = Ember.meta(aNewInstance);
-		var defs = this.getDefinitions();
-		if (defs) {
-			for (p in defs) {
-				meta.descs[p] = new Kojac.EmberModel.TypedField(aNewInstance);
+				if (destType) {
+					extender[p] = Ember.computed(function(aKey,aValue){
+						// MyClass.metaForProperty('person');
+						var m = Ember.meta(this,false);
+						var d = m && m.descs[aKey];
+						var v;
+
+						if (arguments.length==2) { // set
+							var t = d && d._meta && d._meta.type;
+							if (t)
+								v = Kojac.interpretValueAsType(aValue,t);
+							else
+								v = aValue;
+							//cache[aKey] = v;
+						} else {  // get
+							var cache =  m.cache;
+							v = Ember.cacheFor(this,aKey);
+					    if (cache && aKey in cache) {
+					      return cache[aKey];
+					    } else {
+						    return d && d._meta && d._meta.value;
+					    }
+						}
+						return v;
+					}).meta({
+						kemp: true,     // Kojac Ember Model Property
+						type: destType,
+						value: defaultValue
+					})
+				} else {
+					extender[p] = pValue;
+				}
 			}
 		}
-	},
-
-
-	__createWithMixins: Kojac.EmberModel.createWithMixins,
-	createWithMixins: function() {
-		var inputs = arguments;
-		if (inputs.length) {
-			inputs[0] = Kojac.readTypedProperties({},inputs[0],this.getDefinitions());
-		}
-		var result = this.__createWithMixins.apply(this,inputs);
-		this.__addDescs(result);
-		return result;
-  },
-
-	__create: Kojac.EmberModel.create,
-	create: function() {
-		var inputs = arguments;
-		if (inputs.length) {
-			inputs[0] = Kojac.readTypedProperties({},inputs[0],this.getDefinitions());
-		}
-		var result = this.__create.apply(this,inputs);
-		this.__addDescs(result);
+		var result = this._super(extender);
 		return result;
 	}
-
 });
 
-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);
-	},
-
-	// copy the property from source to dest
-	// this could be a static fn
-	toJsonoCopyFn: function(aDest,aSource,aProperty,aOptions) {
-		aDest[aProperty] = Kojac.Utils.toJsono(Ember.get(aSource,aProperty),aOptions);
-	},
-
-	// return array of names, or an object and all keys will be used
-	// this could be a static fn
-	toPropListFn: function(aSource,aOptions) {
-		if ("getDefinitions" in aSource.constructor)
-			return aSource.constructor.getDefinitions();  // return an object to use all keys from
-		else
-			return aSource;    // this is a simple object, so use all keys
-	},
-
-	toJsono: function(aOptions) {
-		return Kojac.Utils.toJsono(this,aOptions,this.toPropListFn,this.toJsonoCopyFn)
-//		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") && ("toJsono" in v))
-//					includes[p] = v.toJsono();
-//			}
-//			_.extend(result,includes);
-//		}
-//		return result;
-	}
-
-});
 
 Kojac.EmberCache = Ember.Object.extend({
 
@@ -299,8 +237,10 @@ Kojac.EmberCache = Ember.Object.extend({
 		this.endPropertyChanges();
 	},
 
-	collectIds: function(aPrefix, aIds) {
-		return Kojac.collectIds(aPrefix,aIds,this);
+	collectIds: function(aPrefix, aIds, aFilterFn) {
+		if (!aIds)
+			aIds = this.get(aPrefix);
+		return Kojac.collectIds(aPrefix,aIds,this,aFilterFn);
 	}
 
 });
@@ -322,7 +262,7 @@ Ember.computed.collectIds = function(aCollectionProperty,aPrefix,aModelCachePath
 	if (!aPrefix)
 		aPrefix = _.last(aCollectionProperty.split('.'));
 
-  return Ember.computed(aCollectionProperty, function(){
+  var result = Ember.computed(aCollectionProperty, function(){
 	  var cache;
 	  if (aModelCachePath)
 	    cache = Ember.Handlebars.get(this,aModelCachePath);  //(aModelCachePath && Ember.get(aModelCachePath));
@@ -331,15 +271,16 @@ Ember.computed.collectIds = function(aCollectionProperty,aPrefix,aModelCachePath
 	  var ids = Ember.Handlebars.get(this,aCollectionProperty);
 	  if (!ids)
 	 		return [];
-	 	var result = [];
+	 	var objects = [];
 	 	var item;
 	 	for (var i=0;i<ids.length;i++) {
 	 		item = cache.get(aPrefix+'__'+ids[i]);
 	 		if (!aFilterFn || aFilterFn(item))
-	 			result.push(item);
+	 			objects.push(item);
 	 	}
-	 	return result;
-  }).property(aModelCachePath,aCollectionProperty);
+	 	return objects;
+  });
+	return result.property.apply(result, _.compact([aModelCachePath,aCollectionProperty]));
 };
 
 Ember.computed.has_many = function(aResource,aForeignKey,aLocalPropertyPath,aModelCachePath,aFilterFn){
@@ -415,7 +356,3 @@ Ember.computed.modelByIdVersioned = function(aIdProperty,aVerProperty,aPrefix,aM
 		}
 	}).property(aModelCachePath,aIdProperty,aVerProperty);
 };
-
-
-
-

data/app/controllers/kojac_base_controller.rb

@@ -1,5 +1,8 @@
+require File.expand_path(File.dirname(__FILE__) + '/kojac_front_methods.rb')
+
 class KojacBaseController < ApplicationController
 
+	include KojacFrontMethods
 	respond_to :json
 	protect_from_forgery :only => []
 
@@ -9,69 +12,11 @@ class KojacBaseController < ApplicationController
 		current_user
 	end
 
-	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.kojac_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)
-    rescue => e
-			raise e unless Rails.env.production?
-			Rails.logger.debug e.message
-			Rails.logger.debug e.backtrace.join("\n")
-			handle_exception(e) if respond_to? :handle_exception
-	    output = {
-		    error: {
-			    format: 'KojacError',
-			    kind: 'Exception',
-		      errors: [{
-			      message: e.message,
-		        backtrace: e.backtrace
-		      }]
-		    }
-	    }
-    end
-		status = output[:error] ? :unprocessable_entity : :ok
-    #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)
-    jsono = KojacUtils.to_jsono(output,scope: kojac_current_user)
-    render json: jsono, status: status
+		jsono,status = process_input(params[:kojac])
+		render json: jsono, status: status
 	end
 
 end

data/app/controllers/kojac_front_methods.rb

@@ -0,0 +1,66 @@
+module KojacFrontMethods
+
+	protected
+
+	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
+
+	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.kojac_current_user
+			result
+		else
+			nil
+		end
+	end
+
+	def process_input(aInputJson)
+		output = nil
+		status = :ok
+
+		begin
+			send(:before_process, [aInputJson]) if respond_to? :before_process
+			output = process_ops(aInputJson)
+		rescue => e
+			#raise e unless Rails.env.production?
+			Rails.logger.debug e.message
+			Rails.logger.debug e.backtrace.join("\n") unless Rails.env.production?
+			handle_exception(e) if respond_to? :handle_exception
+			output = {
+				error: {
+					format: 'KojacError',
+					kind: 'Exception',
+					errors: [{
+						message: e.message
+					}]
+				}
+			}
+			output[:error][:errors][0][:backtrace] = e.backtrace unless Rails.env.production?
+			output
+		end
+		send(:after_process, [aInputJson, output]) if respond_to? :after_process
+		status = output[:error] ? :unprocessable_entity : :ok
+		jsono = KojacUtils.to_jsono(output, scope: kojac_current_user)
+		[jsono,status]
+	end
+
+end

data/app/controllers/kojac_metal_controller.rb

@@ -0,0 +1,25 @@
+require 'json'
+
+class KojacMetalController < ActionController::Metal
+
+	include KojacFrontMethods
+
+	protected
+
+	def current_user
+		@current_user ||= env['warden'].user #User.find_by(id: session[:user])
+	end
+
+	def kojac_current_user
+		current_user
+	end
+
+	public
+
+  def index
+	  input = JSON.parse(request.body.read)
+	  jsono,status = process_input(input['kojac'])
+    self.response_body = jsono.to_json
+	  self.status = status
+  end
+end

data/app/serializers/kojac_base_serializer.rb

@@ -30,6 +30,4 @@ class KojacBaseSerializer < ActiveModel::Serializer
 		end
 		result
 	end
-
-	alias_method :serializable_object, :serializable_hash
 end