active_record_survey 0.1.5 → 0.1.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 89488bc6129619788df343d2782e6e5789b63ea9
-  data.tar.gz: 734de7ad575ef2049f491cc289ddfc798e7f4c30
+  metadata.gz: cc0440e0c23ed5d966185f62fe83619c7d50fa01
+  data.tar.gz: b0e93efb11a6994878ce6c3d5d948043525125a3
 SHA512:
-  metadata.gz: 5c5dd82b54caf2511537e2b3261ff0f90329241500fa4ebe3c83830486e5b3a626ae149a5d59cc9477dbb3a97cde32072f48e85258dc3ff76dd95e284b7dc424
-  data.tar.gz: bbd6dd35bd48ba070e2379ee38a1360fbbaf5e7e027f73c6f10607104d3b2b9886966d423e31ed9772fd84013d1f0794c5a7a504fa184fc996d58c6ed0e71d09
+  metadata.gz: 81b0ea583a5d440eddb185547a584dcf471d8f1618a4f8a0e80406882d7a866c5391851e9eb962f28a90f6308bd3c2aba0c30891b700e28a9737acf19fc04f1e
+  data.tar.gz: 64b747965c5c7bcefe1753f4518f5f4dcbf5279339c459ed1c60a64d854854f77f88ba12410cbd76bb8fd02da05d671fdf1098405405c82384fe19d750eefad8

data/lib/active_record_survey/instance_node.rb

@@ -15,12 +15,18 @@ module ActiveRecordSurvey
 			# Two instance_nodes on the same node for this instance
 			if self.instance.instance_nodes.select { |i|
 					# Two votes share a parent (this means a question has two answers for this instance)
-					(i.node.node_maps.collect { |j| j.parent } & self.node.node_maps.collect { |j| j.parent }).length > 0
+					(i.node.node_maps.collect { |j|
+						j.parent
+					} & self.node.node_maps.collect { |j|
+						j.parent
+					}).length > 0
 				}.length > 1
 				instance_node.errors[:base] << "DUPLICATE_PATH"
 			end
 
-			instance_node.errors[:base] << "INVALID" if !self.node.validate_instance_node(self)
+			if !self.node.validate_instance_node(self)
+				instance_node.errors[:base] << "INVALID"
+			end
 		end
 	end
 end

data/lib/active_record_survey/node/answer/boolean.rb

@@ -7,5 +7,13 @@ module ActiveRecordSurvey
 			super &&
 			!instance_node.value.to_s.match(/^[0|1]$/).nil?
 		end
+
+		# Boolean answers are considered answered if they have a value of "1"
+		def is_answered_for_instance?(instance)
+			if instance_node = self.instance_node_for_instance(instance)
+				# Instance node is answered "1"
+				(instance_node.value.to_i === 1)
+			end
+		end
 	end
 end

data/lib/active_record_survey/node/answer.rb

@@ -1,4 +1,12 @@
 module ActiveRecordSurvey
 	class Node::Answer < Node
+		# Answer nodes are valid if their questions are valid!
+		# Validate this node against an instance
+		def validate_node(instance)
+			# Ensure each parent node to this node (the goal here is to hit a question node) is valid
+			!self.node_maps.collect { |node_map|
+				node_map.parent.node.validate_node(instance)
+			}.include?(false)
+		end
 	end
 end

data/lib/active_record_survey/node.rb

@@ -2,12 +2,48 @@ module ActiveRecordSurvey
 	class Node < ::ActiveRecord::Base
 		self.table_name = "active_record_survey_nodes"
 		has_many :node_maps, :class_name => "ActiveRecordSurvey::NodeMap", :foreign_key => :active_record_survey_node_id
-		has_many :node_validations, :class_name => "ActiveRecordSurvey::NodeValidation", :foreign_key => :active_record_survey_node_id
+		has_many :node_validations, :class_name => "ActiveRecordSurvey::NodeValidation", :foreign_key => :active_record_survey_node_id, autosave: true
+		has_many :instance_nodes, :class_name => "ActiveRecordSurvey::InstanceNode", :foreign_key => :active_record_survey_node_id
 
-		# By default all values are accepted
+		# The instance_node recorded for the passed instance for this node
+		def instance_node_for_instance(instance)
+			instance.instance_nodes.select { |instance_node|
+				(instance_node.node === self)
+			}.first
+		end
+
+		# Whether this node has an answer recorded the instance
+		def has_instance_node_for_instance?(instance)
+			!self.instance_node_for_instance(instance).nil?
+		end
+
+		# Whether considered answered for instance
+		#
+		# Is answered is a little different than has_answer
+		# Is answered is answer type specific, as what constitutes "answered" changes depending on
+		# the question type asked (e.g. boolean is answered if "1")
+		#
+		# Each specific answer type should override this method if they have special criteria for answered
+		#
+		# default - if instance node exists, answered
+		def is_answered_for_instance?(instance)
+			self.has_instance_node_for_instance?(instance)
+		end
+
+		# Run all validations applied to this node
 		def validate_instance_node(instance_node)
+			# UGH - so bsaically this validation doesn't know about the non-saved validation..
+			#puts "Valdating #{self.id} - #{self.text} - total validations are - #{self.node_validations(true).length}"
 			!self.node_validations.collect { |node_validation|
 				node_validation.validate_instance_node(instance_node, self)
+			}.include?(false) &&
+			!self.node_maps.collect { |node_map|
+				if node_map.parent
+					node_map.parent.node.validate_instance_node(instance_node)
+				# Hit top node
+				else
+					true
+				end
 			}.include?(false)
 		end
 

data/lib/active_record_survey/node_map.rb

@@ -22,5 +22,16 @@ module ActiveRecordSurvey
 				}
 			}
 		end
+
+		# Gets all the child nodes until one is not an ancestor of klass
+		def children_until_node_not_ancestor_of(klass)
+			if !self.node.class.ancestors.include?(klass)
+				return []
+			end
+
+			[self] + self.children.collect { |i|
+				i.children_until_node_not_ancestor_of(klass)
+			}
+		end
 	end
 end

data/lib/active_record_survey/node_validation/maximum_answer.rb

@@ -2,9 +2,28 @@ module ActiveRecordSurvey
 	# Ensure the a maximum number of answers are made
 	class NodeValidation::MaximumAnswer < NodeValidation
 		# Validate the instance_node to ensure a maximum number of answers are made
-		def validate_instance_node(instance_node, node = nil)
-			!instance_node.value.to_s.empty? &&
-			instance_node.value.to_f >= self.value.to_f
+		def validate_instance_node(instance_node, question_node = nil)
+			#puts "-------------------------------------------"
+			#puts "runnin min answer validation"
+			
+			# Only makes sense for questions to have minimum answers
+			if !question_node.class.ancestors.include?(::ActiveRecordSurvey::Node::Question)
+				return false 
+			end
+
+			instance = instance_node.instance
+
+			# Go through the node_map of this node
+			total_answered = question_node.node_maps.collect { |question_node_map|
+				# Get all children until a childs node isn't an answer
+				question_node_map.children.collect { |i|
+					i.children_until_node_not_ancestor_of(::ActiveRecordSurvey::Node::Answer)
+				}.flatten.collect { |i|
+					i.node.is_answered_for_instance?(instance)
+				}
+			}.flatten.select { |i| i }.count
+
+			total_answered <= self.value.to_i
 		end
 	end
 end

data/lib/active_record_survey/node_validation/minimum_answer.rb

@@ -2,9 +2,28 @@ module ActiveRecordSurvey
 	# Ensure the a minimum number of answers are made
 	class NodeValidation::MinimumAnswer < NodeValidation
 		# Validate the instance_node to ensure a minimum number of answers are made
-		def validate_instance_node(instance_node, node = nil)
-			!instance_node.value.to_s.empty? &&
-			instance_node.value.to_f >= self.value.to_f
+		def validate_instance_node(instance_node, question_node = nil)
+			#puts "-------------------------------------------"
+			#puts "runnin min answer validation"
+			
+			# Only makes sense for questions to have minimum answers
+			if !question_node.class.ancestors.include?(::ActiveRecordSurvey::Node::Question)
+				return false 
+			end
+
+			instance = instance_node.instance
+
+			# Go through the node_map of this node
+			total_answered = question_node.node_maps.collect { |question_node_map|
+				# Get all children until a childs node isn't an answer
+				question_node_map.children.collect { |i|
+					i.children_until_node_not_ancestor_of(::ActiveRecordSurvey::Node::Answer)
+				}.flatten.collect { |i|
+					i.node.is_answered_for_instance?(instance)
+				}
+			}.flatten.select { |i| i }.count
+
+			total_answered >= self.value.to_i
 		end
 	end
 end

data/lib/active_record_survey/node_validation.rb

@@ -5,8 +5,12 @@ module ActiveRecordSurvey
 		belongs_to :node, :class_name => "ActiveRecordSurvey::Node", :foreign_key => :active_record_survey_node_id
 		
 		# By default everything is valid! WOOO!
-		def validate_instance_node(instance_node, node = nil)
+		def validate_instance_node(instance_node)
 			true
 		end
+		
+		def validate_node(instance_node, node)
+			#code
+		end
 	end
 end

data/lib/active_record_survey/version.rb

@@ -1,3 +1,3 @@
 module ActiveRecordSurvey
-	VERSION = "0.1.5"
+	VERSION = "0.1.6"
 end

data/spec/active_record_survey/node/answer/boolean_spec.rb

@@ -1,18 +1,31 @@
 require 'spec_helper'
 
-describe ActiveRecordSurvey::Node::Answer::Boolean do
+describe ActiveRecordSurvey::Node::Answer::Boolean, :focus => true do
 	describe 'a boolean survey is' do
 		before(:all) do
 			@survey = ActiveRecordSurvey::Survey.new
 
-			@q1 = ActiveRecordSurvey::Node::Question.new(:text => "Please select one")
+			@q1 = ActiveRecordSurvey::Node::Question.new(:text => "Please select two")
 			@q1_a1 = ActiveRecordSurvey::Node::Answer::Boolean.new(:text => "Dog")
 			@q1_a2 = ActiveRecordSurvey::Node::Answer::Boolean.new(:text => "Cat")
 			@q1_a3 = ActiveRecordSurvey::Node::Answer::Boolean.new(:text => "Mouse")
+			@q1_a4 = ActiveRecordSurvey::Node::Answer::Boolean.new(:text => "Tiger")
+			@q1_a5 = ActiveRecordSurvey::Node::Answer::Boolean.new(:text => "Bear")
 
 			nodes = @survey.build_question(@q1, [@q1_a1])
 			nodes = @survey.build_question(@q1_a2, [], nodes[1])
 			nodes = @survey.build_question(@q1_a3, [], nodes[0])
+			nodes = @survey.build_question(@q1_a4, [], nodes[0])
+			nodes = @survey.build_question(@q1_a5, [], nodes[0])
+
+			@q1.node_validations << ActiveRecordSurvey::NodeValidation::MinimumAnswer.new(
+				:node => @q1,
+				:value => 1 # min 1 of the 3 answers must be "answered"
+			)
+			@q1.node_validations << ActiveRecordSurvey::NodeValidation::MaximumAnswer.new(
+				:node => @q1,
+				:value => 3 # max 2 of the 3 answers must be "answered"
+			)
 
 			@survey.save
 		end
@@ -37,6 +50,11 @@ describe ActiveRecordSurvey::Node::Answer::Boolean do
 					:node => @q1_a1,
 					:value => 0
 				)
+				instance.instance_nodes.build(
+					:instance => instance,
+					:node => @q1_a2,
+					:value => 1
+				)
 				instance.save
 
 				expect(instance.valid?).to be(true)
@@ -94,40 +112,122 @@ describe ActiveRecordSurvey::Node::Answer::Boolean do
 		describe ActiveRecordSurvey::NodeValidation::MinimumAnswer do
 			describe 'valid when' do
 				it 'has a value greater than the minimum' do
-					@q1.node_validations << ActiveRecordSurvey::NodeValidation::MinimumAnswer.new(
-						:node => @q1,
-						:value => 2 # 2 of the 3 answers must be "answered"
-					)
 					instance = ActiveRecordSurvey::Instance.new(:survey => @survey)
 					instance.instance_nodes.build(
 						:instance => instance,
 						:node => @q1_a1,
-						:value => "this is greater than minimum length",
+						:value => 1,
+					)
+					instance.instance_nodes.build(
+						:instance => instance,
+						:node => @q1_a2,
+						:value => 0,
+					)
+					instance.instance_nodes.build(
+						:instance => instance,
+						:node => @q1_a3,
+						:value => 1,
 					)
 					instance.save
 	
-					#expect(instance.valid?).to be(true)
+					expect(instance.valid?).to be(true)
 				end
 			end
-=begin
+
 			describe 'invalid when' do
 				it 'has a value less than the minimum' do
-					@q1_a1.node_validations << ActiveRecordSurvey::NodeValidation::MinimumLength.new(
+					instance = ActiveRecordSurvey::Instance.new(:survey => @survey)
+					instance.instance_nodes.build(
+						:instance => instance,
 						:node => @q1_a1,
-						:value => 3
+						:value => 0,
 					)
+					instance.instance_nodes.build(
+						:instance => instance,
+						:node => @q1_a2,
+						:value => 0,
+					)
+					instance.instance_nodes.build(
+						:instance => instance,
+						:node => @q1_a3,
+						:value => 0,
+					)
+					instance.save
+	
+					expect(instance.valid?).to be(false)
+				end
+			end
+		end
+
+
+		describe ActiveRecordSurvey::NodeValidation::MaximumAnswer do
+			describe 'valid when' do
+				it 'has a value less than the maximum' do
 					instance = ActiveRecordSurvey::Instance.new(:survey => @survey)
 					instance.instance_nodes.build(
 						:instance => instance,
 						:node => @q1_a1,
-						:value => "12",
+						:value => 1,
+					)
+					instance.instance_nodes.build(
+						:instance => instance,
+						:node => @q1_a2,
+						:value => 0,
+					)
+					instance.instance_nodes.build(
+						:instance => instance,
+						:node => @q1_a3,
+						:value => 1,
+					)
+					instance.instance_nodes.build(
+						:instance => instance,
+						:node => @q1_a4,
+						:value => 1,
+					)
+					instance.instance_nodes.build(
+						:instance => instance,
+						:node => @q1_a5,
+						:value => 0,
 					)
 					instance.save
+	
+					expect(instance.valid?).to be(true)
+				end
+			end
 
+			describe 'invalid when' do
+				it 'has a value greater than the maximum' do
+					instance = ActiveRecordSurvey::Instance.new(:survey => @survey)
+					instance.instance_nodes.build(
+						:instance => instance,
+						:node => @q1_a1,
+						:value => 1,
+					)
+					instance.instance_nodes.build(
+						:instance => instance,
+						:node => @q1_a2,
+						:value => 1,
+					)
+					instance.instance_nodes.build(
+						:instance => instance,
+						:node => @q1_a3,
+						:value => 1,
+					)
+					instance.instance_nodes.build(
+						:instance => instance,
+						:node => @q1_a4,
+						:value => 1,
+					)
+					instance.instance_nodes.build(
+						:instance => instance,
+						:node => @q1_a5,
+						:value => 1,
+					)
+					instance.save
+	
 					expect(instance.valid?).to be(false)
 				end
 			end
-=end
 		end
 	end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: active_record_survey
 version: !ruby/object:Gem::Version
-  version: 0.1.5
+  version: 0.1.6
 platform: ruby
 authors:
 - Butch Marshall
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-09-25 00:00:00.000000000 Z
+date: 2015-09-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord