kojac 0.9.0 → 0.9.0.1

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    ODkyNDY5NGExYzM1NmM2MGU0NTU0ZGM1YTk0Mjk0MzU1OTQwMmQzZQ==
+    ZmY3Y2Y3OTRjODA1NDQ4MGFkNzQ2YjBlNzEyZWVhZjg1NzI3NWYxNA==
   data.tar.gz: !binary |-
-    NTRlMTFjNTliMDcxMGU5MTQ0OGYzMWY0ZjM5NmY5M2NhNTJmZDM5Yw==
+    MDQyNTNmYmM4YzA4ZTBiYmYzYmI2NWExYmRkNDBjODk5ZjJjNjhlMg==
 !binary "U0hBNTEy":
   metadata.gz: !binary |-
-    NzY3MGYyODk2YzJmMzgzYjY0ZTkzNGJmYjgyYTliMTg4NzQ1ZjdlMzFmMmU4
-    ZTljYjQxZTQzNGQxZjZhMTZlYmYyMjA4NTM5MzQ5MjdjODJmNDIxMDVkNDU3
-    Njk5NDJhNGZlMGViY2NkNmU4ZWZlOWVlM2IxZjRlZThkOGY2YWU=
+    ZjllODJmMWIzMGJjNjlkODNhZTM1N2Q3MTRjOTUyZTI3Y2Q4YzQ1OTgxYTAw
+    MWM5YTAxMDQ1MzAyYTkwMGM4NGQ2YTQ1MmIxM2Y3MzMyZTllMTc4NjA3NThh
+    Y2JlMWM3ODUyYWZhNGEyYWVmNWRjNmI3OTk1MmRjMTEzYTE4Mjc=
   data.tar.gz: !binary |-
-    NDkyOWZmOWVjYmUwYmExMDIxNGJlOTM4M2JmY2U0Y2Q4MWRjOTk1YzA5NTNj
-    NTQzZmI0MmQ4NGE2OWYwMmQ1ZjY2ZDg1ZWQ3YzFlNTQwNzQxZDdhODMwNWM4
-    NjQyNGVhZDc3ZTdlMWIxNjk5OTY3OWJkNDE2MTVjYWRiNjBkY2I=
+    NWQ5OTQ4ZGM4ZDc3M2EyOTBmMjRmZmRhODI3ZDhiYWVlNTE5Y2MwNzhiMDcw
+    MmZhNDk3YTZjNDk1MWE0NGFlMDQyOWM4NzUwODk4NzMyMDY1MGNhZGVkYmQy
+    NzEwMDdiN2I1ZmY4MWFmNjg1Mzc1ZTM4OTIyY2IzYWUzZTAxYzU=

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    kojac (0.9.0)
+    kojac (0.9.0.1)
       jquery-rails
       json2-rails
       strong_parameters

data/lib/kojac/kojac_rails.rb

@@ -63,370 +63,372 @@ module KojacUtils
 
 end
 
-module Kojac::ModelMethods
-
-	def self.included(aClass)
-    aClass.send :extend, ClassMethods
-  end
-
-	module ClassMethods
-		def by_key(aKey,aContext=nil)
-			r,id,a = aKey.split_kojac_key
-			model = self
-			model = self.rescope(model,aContext) if self.respond_to? :rescope
-			if id
-				model.where(id: id).first
-			else
-				model.all
+module Kojac
+	module ModelMethods
+
+		def self.included(aClass)
+	    aClass.send :extend, ClassMethods
+	  end
+
+		module ClassMethods
+			def by_key(aKey,aContext=nil)
+				r,id,a = aKey.split_kojac_key
+				model = self
+				model = self.rescope(model,aContext) if self.respond_to? :rescope
+				if id
+					model.where(id: id).first
+				else
+					model.all
+				end
 			end
 		end
-	end
 
-	def kojac_key
-		self.class.to_s.snake_case.pluralize+'__'+self.id.to_s
-	end
+		def kojac_key
+			self.class.to_s.snake_case.pluralize+'__'+self.id.to_s
+		end
 
-	def update_permitted_attributes!(aChanges, aRing)
-		aChanges = KojacUtils.upgrade_hashes_to_params(aChanges)
-		permitted_fields = self.class.permitted_fields(:write, aRing)
-		permitted_fields = aChanges.permit(*permitted_fields)
-		assign_attributes(permitted_fields, :without_protection => true)
-		save!
-	end
+		def update_permitted_attributes!(aChanges, aRing)
+			aChanges = KojacUtils.upgrade_hashes_to_params(aChanges)
+			permitted_fields = self.class.permitted_fields(:write, aRing)
+			permitted_fields = aChanges.permit(*permitted_fields)
+			assign_attributes(permitted_fields, :without_protection => true)
+			save!
+		end
 
+	end
 end
 
-module Kojac::ControllerOpMethods
-
-	def self.included(aClass)
-    #aClass.send :extend, ClassMethods
-    aClass.send :include, ActiveSupport::Callbacks
-    aClass.send :define_callbacks, :update_op, :scope => [:kind, :name]
-  end
+module Kojac
+	module ControllerOpMethods
 
-	#module ClassMethods
-	#end
+		def self.included(aClass)
+	    #aClass.send :extend, ClassMethods
+	    aClass.send :include, ActiveSupport::Callbacks
+	    aClass.send :define_callbacks, :update_op, :scope => [:kind, :name]
+	  end
 
-	module_function
+		#module ClassMethods
+		#end
 
-	public
+		module_function
 
-	attr_accessor :item
+		public
 
-	def results
-		@results ||= {}
-	end
+		attr_accessor :item
 
-	def deduce_model_class
-		KojacUtils.model_class_for_key(self.kojac_resource)
-	end
+		def results
+			@results ||= {}
+		end
 
-	def kojac_resource
-		self.class.to_s.chomp('Controller').snake_case
-	end
+		def deduce_model_class
+			KojacUtils.model_class_for_key(self.kojac_resource)
+		end
 
-	def create_on_association(aItem,aAssoc,aValues,aRing)
-		raise "User does not have permission for create on #{aAssoc}" unless aItem.class.permitted_associations(:create,aRing).include?(aAssoc.to_sym)
-
-		return nil unless ma = aItem.class.reflect_on_association(aAssoc.to_sym)
-		a_model_class = ma.klass
-
-		aValues = KojacUtils.upgrade_hashes_to_params(aValues || {})
-
-		case ma.macro
-			when :belongs_to
-				return nil if !aValues.is_a?(Hash)
-				fields = aValues.permit( *a_model_class.permitted_fields(:write,aRing) )
-				return aItem.send("build_#{aAssoc}".to_sym,fields)
-			when :has_many
-				aValues = [aValues] if aValues.is_a?(Hash)
-				return nil unless aValues.is_a? Array
-				aValues.each do |v|
-					fields = v.permit( *a_model_class.permitted_fields(:write,aRing) )
-					new_sub_item = nil
-					case ma.macro
-						when :has_many
-							new_sub_item = aItem.send(aAssoc.to_sym).create(fields)
-						else
-							raise "#{ma.macro} association unsupported in CREATE"
-					end
-					merge_model_into_results(new_sub_item)
-				end
+		def kojac_resource
+			self.class.to_s.chomp('Controller').snake_case
 		end
-		#
-		#
-		#
-		#a_value = op[:value][a]        # get data for this association, assume {}
-		#if a_value.is_a?(Hash)
-		#	a_model_class = ma.klass
-		#	fields = a_value.permit( *permitted_fields(:write,a_model_class) )
-		#	item.send("build_#{a}".to_sym,fields)
-		#	included_assocs << a.to_sym
-		#elsif a_value.is_a?(Array)
-		#	raise "association collections not yet implemented for create"
-		#else
-		#	next
-		#end
-	end
 
-	def create_op
-		ring = current_user.try(:ring)
-		op = params[:op]
-		options = op[:options] || {}
-		model_class = deduce_model_class
-		resource,id,assoc = op['key'].split_kojac_key
-		if assoc  # create operation on an association eg. {verb: "CREATE", key: "order.items"}
-			raise "User does not have permission for #{op[:verb]} operation on #{model_class.to_s}.#{assoc}" unless model_class.permitted_associations(:create,ring).include?(assoc.to_sym)
-			item = KojacUtils.model_for_key(key_join(resource,id))
-			ma = model_class.reflect_on_association(assoc.to_sym)
-			a_value = op[:value]        # get data for this association, assume {}
-			raise "create multiple not yet implemented for associations" unless a_value.is_a?(Hash)
+		def create_on_association(aItem,aAssoc,aValues,aRing)
+			raise "User does not have permission for create on #{aAssoc}" unless aItem.class.permitted_associations(:create,aRing).include?(aAssoc.to_sym)
 
+			return nil unless ma = aItem.class.reflect_on_association(aAssoc.to_sym)
 			a_model_class = ma.klass
-			p_fields = a_model_class.permitted_fields(:write,ring)
-			fields = a_value.permit( *p_fields )
-			new_sub_item = nil
+
+			aValues = KojacUtils.upgrade_hashes_to_params(aValues || {})
+
 			case ma.macro
+				when :belongs_to
+					return nil if !aValues.is_a?(Hash)
+					fields = aValues.permit( *a_model_class.permitted_fields(:write,aRing) )
+					return aItem.send("build_#{aAssoc}".to_sym,fields)
 				when :has_many
-					new_sub_item = item.send(assoc.to_sym).create(fields)
-				else
-					raise "#{ma.macro} association unsupported in CREATE"
+					aValues = [aValues] if aValues.is_a?(Hash)
+					return nil unless aValues.is_a? Array
+					aValues.each do |v|
+						fields = v.permit( *a_model_class.permitted_fields(:write,aRing) )
+						new_sub_item = nil
+						case ma.macro
+							when :has_many
+								new_sub_item = aItem.send(aAssoc.to_sym).create(fields)
+							else
+								raise "#{ma.macro} association unsupported in CREATE"
+						end
+						merge_model_into_results(new_sub_item)
+					end
 			end
-			result_key = op[:result_key] || new_sub_item.kojac_key
-			merge_model_into_results(new_sub_item)
-		else    # create operation on a resource eg. {verb: "CREATE", key: "order_items"} but may have embedded association values
-			p_fields = model_class.permitted_fields(:write,ring)
-			raise "User does not have permission for #{op[:verb]} operation on #{model_class.to_s}" unless model_class.ring_can?(:create,ring)
-
-			p_fields = op[:value].permit( *p_fields )
-			item = model_class.create!(p_fields)
-
-			options_include = options['include'] || []
-			included_assocs = []
-			p_assocs = model_class.permitted_associations(:write,ring)
-			if p_assocs
-				p_assocs.each do |a|
-					next unless (a_value = op[:value][a]) || options_include.include?(a.to_s)
-					create_on_association(item,a,a_value,ring)
-					included_assocs << a.to_sym
+			#
+			#
+			#
+			#a_value = op[:value][a]        # get data for this association, assume {}
+			#if a_value.is_a?(Hash)
+			#	a_model_class = ma.klass
+			#	fields = a_value.permit( *permitted_fields(:write,a_model_class) )
+			#	item.send("build_#{a}".to_sym,fields)
+			#	included_assocs << a.to_sym
+			#elsif a_value.is_a?(Array)
+			#	raise "association collections not yet implemented for create"
+			#else
+			#	next
+			#end
+		end
+
+		def create_op
+			ring = current_user.try(:ring)
+			op = params[:op]
+			options = op[:options] || {}
+			model_class = deduce_model_class
+			resource,id,assoc = op['key'].split_kojac_key
+			if assoc  # create operation on an association eg. {verb: "CREATE", key: "order.items"}
+				raise "User does not have permission for #{op[:verb]} operation on #{model_class.to_s}.#{assoc}" unless model_class.permitted_associations(:create,ring).include?(assoc.to_sym)
+				item = KojacUtils.model_for_key(key_join(resource,id))
+				ma = model_class.reflect_on_association(assoc.to_sym)
+				a_value = op[:value]        # get data for this association, assume {}
+				raise "create multiple not yet implemented for associations" unless a_value.is_a?(Hash)
+
+				a_model_class = ma.klass
+				p_fields = a_model_class.permitted_fields(:write,ring)
+				fields = a_value.permit( *p_fields )
+				new_sub_item = nil
+				case ma.macro
+					when :has_many
+						new_sub_item = item.send(assoc.to_sym).create(fields)
+					else
+						raise "#{ma.macro} association unsupported in CREATE"
 				end
+				result_key = op[:result_key] || new_sub_item.kojac_key
+				merge_model_into_results(new_sub_item)
+			else    # create operation on a resource eg. {verb: "CREATE", key: "order_items"} but may have embedded association values
+				p_fields = model_class.permitted_fields(:write,ring)
+				raise "User does not have permission for #{op[:verb]} operation on #{model_class.to_s}" unless model_class.ring_can?(:create,ring)
+
+				p_fields = op[:value].permit( *p_fields )
+				item = model_class.create!(p_fields)
+
+				options_include = options['include'] || []
+				included_assocs = []
+				p_assocs = model_class.permitted_associations(:write,ring)
+				if p_assocs
+					p_assocs.each do |a|
+						next unless (a_value = op[:value][a]) || options_include.include?(a.to_s)
+						create_on_association(item,a,a_value,ring)
+						included_assocs << a.to_sym
+					end
+				end
+				item.save!
+				result_key = op[:result_key] || item.kojac_key
+				merge_model_into_results(item,result_key,:include => included_assocs)
 			end
-			item.save!
-			result_key = op[:result_key] || item.kojac_key
-			merge_model_into_results(item,result_key,:include => included_assocs)
+			{
+				key: op[:key],
+			  verb: op[:verb],
+			  result_key: result_key,
+			  results: results
+			}
 		end
-		{
-			key: op[:key],
-		  verb: op[:verb],
-		  result_key: result_key,
-		  results: results
-		}
-	end
 
-	protected
-
-	def merge_model_into_results(aItem,aResultKey=nil,aOptions=nil)
-		ring = current_user.try(:ring)
-		aResultKey ||= aItem.kojac_key
-		aOptions ||= {}
-		results[aResultKey] = aItem.sanitized_hash(ring)
-		if included_assocs = aOptions[:include]
-			included_assocs = included_assocs.split(',') if included_assocs.is_a?(String)
-			included_assocs = [included_assocs] unless included_assocs.is_a?(Array)
-			included_assocs.map!(&:to_sym) if included_assocs.is_a?(Array)
-			p_assocs = aItem.class.permitted_associations(:read,ring)
-			use_assocs = p_assocs.delete_if do |a|
-				if included_assocs.include?(a) and ma = aItem.class.reflect_on_association(a)
-					![:belongs_to,:has_many].include?(ma.macro)   # is supported association type
-				else
-					true  # no such assoc
+		protected
+
+		def merge_model_into_results(aItem,aResultKey=nil,aOptions=nil)
+			ring = current_user.try(:ring)
+			aResultKey ||= aItem.kojac_key
+			aOptions ||= {}
+			results[aResultKey] = aItem.sanitized_hash(ring)
+			if included_assocs = aOptions[:include]
+				included_assocs = included_assocs.split(',') if included_assocs.is_a?(String)
+				included_assocs = [included_assocs] unless included_assocs.is_a?(Array)
+				included_assocs.map!(&:to_sym) if included_assocs.is_a?(Array)
+				p_assocs = aItem.class.permitted_associations(:read,ring)
+				use_assocs = p_assocs.delete_if do |a|
+					if included_assocs.include?(a) and ma = aItem.class.reflect_on_association(a)
+						![:belongs_to,:has_many].include?(ma.macro)   # is supported association type
+					else
+						true  # no such assoc
+					end
 				end
-			end
-			use_assocs.each do |a|
-				next unless a_contents = aItem.send(a)
-				if a_contents.is_a? Array
-					contents_h = []
-					a_contents.each do |sub_item|
-						results[sub_item.kojac_key] = sub_item.sanitized_hash(ring)
-						#contents_h << sub_item.id
+				use_assocs.each do |a|
+					next unless a_contents = aItem.send(a)
+					if a_contents.is_a? Array
+						contents_h = []
+						a_contents.each do |sub_item|
+							results[sub_item.kojac_key] = sub_item.sanitized_hash(ring)
+							#contents_h << sub_item.id
+						end
+						#results[aResultKey] = contents_h
+					else
+						results[a_contents.kojac_key] = a_contents.sanitized_hash(ring)
 					end
-					#results[aResultKey] = contents_h
-				else
-					results[a_contents.kojac_key] = a_contents.sanitized_hash(ring)
 				end
 			end
 		end
-	end
 
-	public
-
-	def read_op
-		op = params[:op]
-		key = op[:key]
-		result_key = nil
-		resource,id = key.split '__'
-		model = deduce_model_class
-
-		if id   # item
-			if model
-				item = model.by_key(key,op)
-				result_key = op[:result_key] || (item && item.kojac_key) || op[:key]
-				merge_model_into_results(item,result_key,op[:options])
-			else
+		public
+
+		def read_op
+			op = params[:op]
+			key = op[:key]
+			result_key = nil
+			resource,id = key.split '__'
+			model = deduce_model_class
+
+			if id   # item
+				if model
+					item = model.by_key(key,op)
+					result_key = op[:result_key] || (item && item.kojac_key) || op[:key]
+					merge_model_into_results(item,result_key,op[:options])
+				else
+					result_key = op[:result_key] || op[:key]
+					results[result_key] = null
+				end
+			else    # collection
 				result_key = op[:result_key] || op[:key]
-				results[result_key] = null
-			end
-		else    # collection
-			result_key = op[:result_key] || op[:key]
-			results[result_key] = []
-			if model
-				items = model.by_key(key,op)
-				items.each do |m|
-					item_key = m.kojac_key
-					results[result_key] << item_key.bite(resource+'__')
-					merge_model_into_results(m,item_key,op[:options])
+				results[result_key] = []
+				if model
+					items = model.by_key(key,op)
+					items.each do |m|
+						item_key = m.kojac_key
+						results[result_key] << item_key.bite(resource+'__')
+						merge_model_into_results(m,item_key,op[:options])
+					end
 				end
 			end
+			{
+				key: op[:key],
+			  verb: op[:verb],
+			  results: results,
+			  result_key: result_key
+			}
 		end
-		{
-			key: op[:key],
-		  verb: op[:verb],
-		  results: results,
-		  result_key: result_key
-		}
-	end
 
-	def update_op
-		result = nil
-		model = deduce_model_class
-
-		ring = current_user.try(:ring)
-		op = params[:op]
-		result_key = nil
-		if self.item = model.by_key(op[:key],op)
-
-			run_callbacks :update_op do
-				item.update_permitted_attributes!(op[:value], ring)
-
-				associations = model.permitted_associations(:write,ring)
-				associations.each do |k|
-					next unless assoc = model.reflect_on_association(k)
-					next unless op[:value][k]
-					case assoc.macro
-						when :belongs_to
-							if leaf = (item.send(k) || item.send("build_#{k}".to_sym))
-								#permitted_fields = leaf.class.permitted_fields(:write,ring)
-								#permitted_fields = op[:value][k].permit( *permitted_fields )
-								#leaf.assign_attributes(permitted_fields, :without_protection => true)
-								#leaf.save!
-								leaf.update_permitted_attributes!(op[:value][k], ring)
-							end
+		def update_op
+			result = nil
+			model = deduce_model_class
+
+			ring = current_user.try(:ring)
+			op = params[:op]
+			result_key = nil
+			if self.item = model.by_key(op[:key],op)
+
+				run_callbacks :update_op do
+					item.update_permitted_attributes!(op[:value], ring)
+
+					associations = model.permitted_associations(:write,ring)
+					associations.each do |k|
+						next unless assoc = model.reflect_on_association(k)
+						next unless op[:value][k]
+						case assoc.macro
+							when :belongs_to
+								if leaf = (item.send(k) || item.send("build_#{k}".to_sym))
+									#permitted_fields = leaf.class.permitted_fields(:write,ring)
+									#permitted_fields = op[:value][k].permit( *permitted_fields )
+									#leaf.assign_attributes(permitted_fields, :without_protection => true)
+									#leaf.save!
+									leaf.update_permitted_attributes!(op[:value][k], ring)
+								end
+						end
 					end
-				end
 
-				result_key = item.kojac_key
-				results[result_key] = item
+					result_key = item.kojac_key
+					results[result_key] = item
 
-				associations.each do |a|
-					next unless assoc_item = item.send(a)
-					next unless key = assoc_item.respond_to?(:kojac_key) && assoc_item.kojac_key
-					results[key] = assoc_item
+					associations.each do |a|
+						next unless assoc_item = item.send(a)
+						next unless key = assoc_item.respond_to?(:kojac_key) && assoc_item.kojac_key
+						results[key] = assoc_item
+					end
 				end
 			end
+			{
+				key: op[:key],
+			  verb: op[:verb],
+			  result_key: result_key,
+			  results: results
+			}
 		end
-		{
-			key: op[:key],
-		  verb: op[:verb],
-		  result_key: result_key,
-		  results: results
-		}
-	end
-
-	def destroy_op
-		ring = current_user.try(:ring)
-		op = params[:op]
-		result_key = op[:result_key] || op[:key]
-		item = KojacUtils.model_for_key(op[:key])
-		item.destroy if item
-		results[result_key] = nil
-		{
-			key: op[:key],
-		  verb: op[:verb],
-		  result_key: result_key,
-		  results: results
-		}
-	end
 
-	#def execute_op
-	#	puts 'execute_op'
-	#end
-
-	def add_op
-		ring = current_user.try(:ring)
-		op = params[:op]
-		model = deduce_model_class
-		raise "ADD only supports associated collections at present eg order.items" unless op[:key].index('.')
-
-		item = KojacUtils.model_for_key(op[:key].base_key)
-		assoc = (assoc=op[:key].key_assoc) && assoc.to_sym
-		id = op[:value]['id']
-
-		ma = item.class.reflect_on_association(assoc)
-		case ma.macro
-			when :has_many
-				assoc_class = ma.klass
-				assoc_item = assoc_class.find(id)
-				item.send(assoc) << assoc_item
-
-				#ids_method = assoc.to_s.singularize+'_ids'
-				#ids = item.send(ids_method.to_sym)
-				#item.send((ids_method+'=').to_sym,ids + [id])
-				result_key = assoc_item.kojac_key
-				merge_model_into_results(assoc_item)
-			else
-				raise "ADD does not yet support #{ma.macro} associations"
+		def destroy_op
+			ring = current_user.try(:ring)
+			op = params[:op]
+			result_key = op[:result_key] || op[:key]
+			item = KojacUtils.model_for_key(op[:key])
+			item.destroy if item
+			results[result_key] = nil
+			{
+				key: op[:key],
+			  verb: op[:verb],
+			  result_key: result_key,
+			  results: results
+			}
 		end
-		{
-			key: op[:key],
-		  verb: op[:verb],
-		  result_key: result_key,
-		  results: results
-		}
-	end
 
-	def remove_op
-		ring = current_user.try(:ring)
-		op = params[:op]
-		model = deduce_model_class
-		raise "REMOVE only supports associated collections at present eg order.items" unless op[:key].key_assoc
-
-		item = KojacUtils.model_for_key(op[:key].base_key)
-		assoc = (assoc=op[:key].key_assoc) && assoc.to_sym
-		id = op[:value]['id']
-
-		ma = item.class.reflect_on_association(assoc)
-		case ma.macro
-			when :has_many
-				assoc_class = ma.klass
-				if assoc_item = item.send(assoc).find(id)
-					item.send(assoc).delete(assoc_item)
+		#def execute_op
+		#	puts 'execute_op'
+		#end
+
+		def add_op
+			ring = current_user.try(:ring)
+			op = params[:op]
+			model = deduce_model_class
+			raise "ADD only supports associated collections at present eg order.items" unless op[:key].index('.')
+
+			item = KojacUtils.model_for_key(op[:key].base_key)
+			assoc = (assoc=op[:key].key_assoc) && assoc.to_sym
+			id = op[:value]['id']
+
+			ma = item.class.reflect_on_association(assoc)
+			case ma.macro
+				when :has_many
+					assoc_class = ma.klass
+					assoc_item = assoc_class.find(id)
+					item.send(assoc) << assoc_item
+
+					#ids_method = assoc.to_s.singularize+'_ids'
+					#ids = item.send(ids_method.to_sym)
+					#item.send((ids_method+'=').to_sym,ids + [id])
 					result_key = assoc_item.kojac_key
-					if (assoc_item.destroyed?)
-						results[result_key] = nil
-					else
-						merge_model_into_results(assoc_item,result_key)
-					end
-				end
-			else
-				raise "REMOVE does not yet support #{ma.macro} associations"
+					merge_model_into_results(assoc_item)
+				else
+					raise "ADD does not yet support #{ma.macro} associations"
+			end
+			{
+				key: op[:key],
+			  verb: op[:verb],
+			  result_key: result_key,
+			  results: results
+			}
 		end
-		{
-			key: op[:key],
-		  verb: op[:verb],
-		  result_key: result_key,
-		  results: results
-		}
-	end
 
+		def remove_op
+			ring = current_user.try(:ring)
+			op = params[:op]
+			model = deduce_model_class
+			raise "REMOVE only supports associated collections at present eg order.items" unless op[:key].key_assoc
 
+			item = KojacUtils.model_for_key(op[:key].base_key)
+			assoc = (assoc=op[:key].key_assoc) && assoc.to_sym
+			id = op[:value]['id']
+
+			ma = item.class.reflect_on_association(assoc)
+			case ma.macro
+				when :has_many
+					assoc_class = ma.klass
+					if assoc_item = item.send(assoc).find(id)
+						item.send(assoc).delete(assoc_item)
+						result_key = assoc_item.kojac_key
+						if (assoc_item.destroyed?)
+							results[result_key] = nil
+						else
+							merge_model_into_results(assoc_item,result_key)
+						end
+					end
+				else
+					raise "REMOVE does not yet support #{ma.macro} associations"
+			end
+			{
+				key: op[:key],
+			  verb: op[:verb],
+			  result_key: result_key,
+			  results: results
+			}
+		end
+	end
 end

data/lib/kojac/version.rb

@@ -1,3 +1,3 @@
 module Kojac
-  VERSION = "0.9.0"
+  VERSION = "0.9.0.1"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: kojac
 version: !ruby/object:Gem::Version
-  version: 0.9.0
+  version: 0.9.0.1
 platform: ruby
 authors:
 - Gary McGhee