active_record_survey 0.1.25 → 0.1.26

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2e31b5194f981037636d99848bcf20cca47ff08d
-  data.tar.gz: 826afd06292c6edb0c7c66c125d09f719960b656
+  metadata.gz: d9764b3647e3386e4d60b9753940515b78881b88
+  data.tar.gz: 899bf6944ac349d04d2aca7b20254837a2a93bd2
 SHA512:
-  metadata.gz: d549e57755d6ccbfdd39d65a5250076de67bf434412f8ecbdce4009bfceb275ef935acd4f49bec8025269fc35127f08e9810a4b574889bd7c3cab7ccd2154f0b
-  data.tar.gz: bda3002f375e5dccff9be201873e2ca52fa3a482271ea4f730035f20c3e46ed01e8bbffc7706454f72179589e8e8b7d34feaf8717f5451823916d8755f9ec783
+  metadata.gz: 765649c5e0aa37a8b02fac5ef171852d45f4a5145ea414f1486a4fa73f3b95834bee2f68192145681bd3975cba6e1b580eb09d959e139a9c59ea95f2b1d46402
+  data.tar.gz: b23afb8a510de738c55fd823fdc03d498471b4e4c65e4b3eca5a9ff7a919a5359e066b8e0ea782b4adeddbb28083f33c8310d034f24e6d73c4dd9377752e9a26

data/README.md

@@ -12,6 +12,11 @@ The goal is to give a simple interface for creating surveys and validating the a
 Release Notes
 ============
 
+**0.1.26**
+ - Major refactor of answer#build_link and answer#remove_link
+ - `ActiveRecordSurvey::Node` now has a direct reference to its survey.  Don't forget to run the install task Update_0_1_26_ActiveRecordSurvey
+ - survey#build_question removed, no longer needed, just use survey.questions.build
+
 **0.1.24**
  - Refactored class `ActiveRecordSurvey::Node::Answer::Chain` to module `ActiveRecordSurvey::Node::Answer::Chained` - this functionality makes way more sense implemented as a module.
 
@@ -72,38 +77,34 @@ The usage below with `:text => ""` will not actually work unless you implement `
 ### Build a basic survey
 ```ruby
 
-# New method for building surveys
+# Building surveys
 @survey = ActiveRecordSurvey::Survey.new()
 
-@q1 = ActiveRecordSurvey::Node::Question.new(:text => "Question #1")
-@survey.build_question(@q1)
+@q1 = @survey.questions.build(:type => "ActiveRecordSurvey::Node::Question", :text => "Question #1", :survey => @survey)
 @q1_a1 = ActiveRecordSurvey::Node::Answer.new(:text => "Q1 Answer #1")
 @q1_a2 = ActiveRecordSurvey::Node::Answer.new(:text => "Q1 Answer #2")
 @q1_a3 = ActiveRecordSurvey::Node::Answer.new(:text => "Q1 Answer #3")
-@q1.build_answer(@q1_a1, @survey)
-@q1.build_answer(@q1_a2, @survey)
-@q1.build_answer(@q1_a3, @survey)
+@q1.build_answer(@q1_a1)
+@q1.build_answer(@q1_a2)
+@q1.build_answer(@q1_a3)
 
-@q2 = ActiveRecordSurvey::Node::Question.new(:text => "Question #2")
-@survey.build_question(@q2)
+@q2 = @survey.questions.build(:type => "ActiveRecordSurvey::Node::Question", :text => "Question #2", :survey => @survey)
 @q2_a1 = ActiveRecordSurvey::Node::Answer.new(:text => "Q2 Answer #1")
 @q2_a2 = ActiveRecordSurvey::Node::Answer.new(:text => "Q2 Answer #2")
-@q2.build_answer(@q2_a1, @survey)
-@q2.build_answer(@q2_a2, @survey)
+@q2.build_answer(@q2_a1)
+@q2.build_answer(@q2_a2)
 
-@q3 = ActiveRecordSurvey::Node::Question.new(:text => "Question #3")
-@survey.build_question(@q3)
+@q3 = @survey.questions.build(:type => "ActiveRecordSurvey::Node::Question", :text => "Question #3", :survey => @survey)
 @q3_a1 = ActiveRecordSurvey::Node::Answer.new(:text => "Q3 Answer #1")
 @q3_a2 = ActiveRecordSurvey::Node::Answer.new(:text => "Q3 Answer #2")
-@q3.build_answer(@q3_a1, @survey)
-@q3.build_answer(@q3_a2, @survey)
+@q3.build_answer(@q3_a1)
+@q3.build_answer(@q3_a2)
 
-@q4 = ActiveRecordSurvey::Node::Question.new(:text => "Question #4")
-@survey.build_question(@q4)
+@q4 = @survey.questions.build(:type => "ActiveRecordSurvey::Node::Question", :text => "Question #4", :survey => @survey)
 @q4_a1 = ActiveRecordSurvey::Node::Answer.new(:text => "Q4 Answer #1")
 @q4_a2 = ActiveRecordSurvey::Node::Answer.new(:text => "Q4 Answer #2")
-@q4.build_answer(@q4_a1, @survey)
-@q4.build_answer(@q4_a2, @survey)
+@q4.build_answer(@q4_a1)
+@q4.build_answer(@q4_a2)
 
 # Link up Q1
 @q1_a1.build_link(@q2)

data/active_record_survey.gemspec

@@ -19,7 +19,7 @@ Gem::Specification.new do |spec|
 	spec.require_paths = ["lib"]
 
 	spec.add_dependency "activerecord", [">= 3.0", "< 5.0"]
-	spec.add_dependency "awesome_nested_set", [">= 2.0"]
+	spec.add_dependency "awesome_nested_set", [">= 3.0"]
 	if RUBY_PLATFORM == 'java'
 		spec.add_development_dependency "jdbc-sqlite3", "> 0"
 		spec.add_development_dependency "activerecord-jdbcsqlite3-adapter", "> 0"

data/lib/active_record_survey/instance_node.rb

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

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

@@ -2,19 +2,24 @@ module ActiveRecordSurvey
 	class Answer
 		module Chained
 			# Chain nodes are different - they must find the final answer node added and add to it
-			def build_answer(question_node, survey)
+			def build_answer(question_node)
+				self.survey = question_node.survey
+
+				question_node_maps = self.survey.node_maps.select { |i| i.node == question_node && !i.marked_for_destruction? }
+
 				# No node_maps exist yet from this question
-				if question_node.node_maps.length === 0
+				if question_node_maps.length === 0
 					# Build our first node-map
-					question_node.node_maps.build(:node => question_node, :survey => survey)
+					question_node_maps << self.survey.node_maps.build(:node => question_node, :survey => self.survey)
 				end
 
-				last_in_chain = question_node.answers.last || question_node
+				last_answer_in_chain = (question_node.answers.last || question_node)
 
 				# Each instance of this question needs the answer hung from it
-				last_in_chain.node_maps.each { |node_map|
-					answer_node_map = self.node_maps.build(:node => self, :survey => survey)
-					node_map.children << answer_node_map
+				self.survey.node_maps.select { |i|
+					i.node == last_answer_in_chain
+				}.each { |node_map|
+					node_map.children << self.survey.node_maps.build(:node => self, :survey => self.survey)
 				}
 
 				true

data/lib/active_record_survey/node/answer.rb

@@ -4,14 +4,18 @@ module ActiveRecordSurvey
 		# 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|
+			!self.survey.node_maps.select { |i|
+				i.node == self
+			}.collect { |node_map|
 				node_map.parent.node.validate_node(instance)
 			}.include?(false)
 		end
 
 		# Returns the question that preceeds this answer
 		def question
-			self.node_maps.collect { |node_map|
+			self.survey.node_maps.select { |i|
+				i.node == self
+			}.collect { |node_map|
 				if node_map.parent && node_map.parent.node
 					# Question is not the next parent - recurse!
 					if node_map.parent.node.class.ancestors.include?(::ActiveRecordSurvey::Node::Answer)
@@ -28,9 +32,11 @@ module ActiveRecordSurvey
 
 		# Returns the question that follows this answer
 		def next_question
-			self.node_maps.each { |answer_node_map|
+			self.survey.node_maps.select { |i|
+				i.node == self && !i.marked_for_destruction?
+			}.each { |answer_node_map|
 				answer_node_map.children.each { |child|
-					if !child.node.nil?
+					if !child.node.nil? && !child.marked_for_destruction?
 						if child.node.class.ancestors.include?(::ActiveRecordSurvey::Node::Question)
 							return child.node
 						elsif child.node.class.ancestors.include?(::ActiveRecordSurvey::Node::Answer)
@@ -44,40 +50,32 @@ module ActiveRecordSurvey
 			return nil
 		end
 
-		attr_accessor :ancestor_marked_for_destruction
-		protected :ancestor_marked_for_destruction
-
-		before_save do |node|
-			# ------------------------ WARNING ------------------------
-			# This code is to support #remove_link which uses mark_for_destruction
-			# This code is necessary to clean everything up.
-			# Calling save on this answer won't automatically go to its next_question -> node_maps and clean everything up
-			(@ancestor_marked_for_destruction || []).each { |i|
-				i.destroy
-			}
-		end
-
 		# Removes the link
 		def remove_link
-			@ancestor_marked_for_destruction ||= []
-
 			# not linked to a question - nothing to remove!
 			return true if (question = self.next_question).nil?
 
-			self.node_maps.each_with_index { |answer_nm, answer_nm_i|
-				answer_nm.children = answer_nm.children.select { |question_nm|
-					# This node_map links to the question
-					if question_nm.node === question
-						question_nm.parent = nil
-						if answer_nm_i > 0
-							question_nm.mark_for_destruction
-							@ancestor_marked_for_destruction << question_nm
-						end
-						false
+			count = 0
+			to_remove = []
+			self.survey.node_maps.each { |node_map|
+				if node_map.node == question
+					if count > 0
+						to_remove.concat(node_map.self_and_descendants)
 					else
-						true
+						node_map.parent = nil
 					end
-				}
+					count = count + 1
+				end
+
+				if node_map.node == self
+					node_map.children = []
+				end
+			}
+			self.survey.node_maps.each { |node_map|
+				if to_remove.include?(node_map)
+					node_map.parent = nil
+					node_map.mark_for_destruction
+				end
 			}
 		end
 
@@ -89,48 +87,47 @@ module ActiveRecordSurvey
 				raise ArgumentError.new "to_node must inherit from ::ActiveRecordSurvey::Node::Question"
 			end
 
+			if self.question.nil?
+				raise ArgumentError.new "A question is required before calling #build_link"
+			end
+
+			if self.survey.nil?
+				raise ArgumentError.new "A survey is required before calling #build_link"
+			end
+
+			from_node_maps = self.survey.node_maps.select { |i| i.node == self && !i.marked_for_destruction? }
+
 			# Answer has already got a question - throw error
-			if self.node_maps.select { |i|
+			if from_node_maps.select { |i|
 				i.children.length === 0
 			}.length === 0
 				raise RuntimeError.new "This answer has already been linked" 
 			end
 
-			# Attempt to find an unused to_node node_map
-			if !(to_without_parent = to_node.node_maps.select { |i| i.parent.nil? }.first)
-				# no unused path exists
-				# we need to recursively clone the existing path
-
-				to_node_map = to_node.node_maps.first || to_node.node_maps.build(:node => to_node, :survey => self.node_maps.first.survey)
+			# Because we need something to clone - filter this further below
+			to_node_maps = self.survey.node_maps.select { |i| i.node == to_node && !i.marked_for_destruction? }
 
-				# Add it to all the from_node_maps
-				self.node_maps.each { |from_node_map|
-					from_node_map.children << to_node_map.recursive_clone
-				}
-			else
-				# Find the node map from this node that has no children
-				from_with_no_children = self.node_maps.select { |i|
-					i.children.length == 0
-				}
+			if to_node_maps.first.nil?
+				to_node_maps << self.survey.node_maps.build(:survey => self.survey, :node => to_node)
+			end
 
-				if from_with_no_children.length > 1
-					to_node_map = to_node.node_maps.first || to_node.node_maps.build(:node => to_node, :survey => self.node_maps.first.survey)
-				end
+			# Ensure we can through each possible path of getting to this answer
+			to_node_map = to_node_maps.first
+			to_node_map.survey = self.survey # required due to voodoo - we want to use the same survey with the same object_id
 
-				from_with_no_children.each_with_index { |from_with_no_children, index|
-					# Use up the node that hasn't been used yet
-					if index === 0
-						from_with_no_children.children << to_without_parent
-					# We need to clone destinations for each of the subsequent
-					else
-						from_with_no_children.children << to_node_map.recursive_clone
-					end
-				}
-
-				# TODO - check to make sure there is no path to itself
+			# We only want node maps that aren't linked somewhere
+			to_node_maps = to_node_maps.select { |i| i.parent.nil? }
+			while to_node_maps.length < from_node_maps.length do
+				to_node_maps.push(to_node_map.recursive_clone)
 			end
 
-			self.node_maps.each { |node_map|
+			# Link unused node_maps to the new parents
+			from_node_maps.each_with_index { |from_node_map, index|
+				from_node_map.children << to_node_maps[index]
+			}
+
+			# Ensure no infinite loops were created
+			from_node_maps.each { |node_map|
 				# There is a path from Q -> A that is a loop
 				if node_map.has_infinite_loop?
 					raise RuntimeError.new "Infinite loop detected"
@@ -138,24 +135,27 @@ module ActiveRecordSurvey
 			}
 		end
 
-		# By default - answers build off the original question node
-		#
-		# This allows us to easily override the answer building behaviour for different answer types
-		#
-		def build_answer(question_node, survey)
-			# No node_maps exist yet from this question
-			if question_node.node_maps.length === 0
-				# Build our first node-map
-				question_node.node_maps.build(:node => question_node, :survey => survey)
-			end
+		private
+			# By default - answers build off the original question node
+			#
+			# This allows us to easily override the answer building behaviour for different answer types
+			def build_answer(question_node)
+				self.survey = question_node.survey
 
-			# Each instance of this question needs the answer hung from it
-			question_node.node_maps.each { |question_node_map|
-				answer_node_map = self.node_maps.build(:node => self, :survey => survey)
-				question_node_map.children << answer_node_map
-			}
+				question_node_maps = self.survey.node_maps.select { |i| i.node == question_node && !i.marked_for_destruction? }
 
-			true
-		end
+				# No node_maps exist yet from this question
+				if question_node_maps.length === 0
+					# Build our first node-map
+					question_node_maps << self.survey.node_maps.build(:node => question_node, :survey => self.survey)
+				end
+
+				# Each instance of this question needs the answer hung from it
+				question_node_maps.each { |question_node_map|
+					question_node_map.children << self.survey.node_maps.build(:node => self, :survey => self.survey)
+				}
+
+				true
+			end
 	end
 end

data/lib/active_record_survey/node/question.rb

@@ -7,28 +7,15 @@ module ActiveRecordSurvey
 			}.include?(false)
 		end
 
-		# Returns the survey to the question
-		def survey
-			if node_map = self.node_maps.first
-				node_map.survey
-			end
-		end
-
 		# Build an answer off this node
-		def build_answer(answer_node, survey = nil)
-			survey = survey || self.node_maps.select { |i|
-				!i.survey.nil?
-			}.collect { |i|
-				i.survey
-			}.first
-
-			# A survey must either be passed or already present in node_maps
-			if survey.nil?
+		def build_answer(answer_node)
+			# A survey must either be passed or already present in self.node_maps
+			if self.survey.nil?
 				raise ArgumentError.new "A survey must be passed if Question is not yet added to a survey"
 			end
 
-			# Answers actually define how they're built off the parent node... yep
-			answer_node.build_answer(self, survey)
+			# Answers actually define how they're built off the parent node
+			answer_node.send(:build_answer, self)
 		end
 	end
 end

data/lib/active_record_survey/node.rb

@@ -1,13 +1,16 @@
 module ActiveRecordSurvey
 	class Node < ::ActiveRecord::Base
 		self.table_name = "active_record_survey_nodes"
+		belongs_to :survey, :class_name => "ActiveRecordSurvey::Survey", :foreign_key => :active_record_survey_id
 		has_many :node_maps, :class_name => "ActiveRecordSurvey::NodeMap", :foreign_key => :active_record_survey_node_id, autosave: true
 		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
 
 		# All the answer nodes that follow from this node
 		def answers
-			self.node_maps.collect { |i|
+			self.survey.node_maps.select { |i|
+				i.node == self
+			}.collect { |i|
 				# Get all the children from this node
 				i.children
 			}.flatten.collect { |i|
@@ -17,6 +20,7 @@ module ActiveRecordSurvey
 				# Only the nodes that are answers
 				i.class.ancestors.include?(::ActiveRecordSurvey::Node::Answer)
 			}.uniq.collect { |i|
+				i.survey = self.survey # ensure that the survey being referenced by the answers is the original survey - needed for keeping consistent node_maps between build_link and remove_link
 				[i] + i.answers
 			}.flatten.uniq
 		end
@@ -48,7 +52,7 @@ module ActiveRecordSurvey
 
 		# Default behaviour is to recurse up the chain (goal is to hit a question node)
 		def validate_parent_instance_node(instance_node, child_node)
-			!self.node_maps.collect { |node_map|
+			!self.survey.node_maps.select { |i| i.node == self}.collect { |node_map|
 				if node_map.parent
 					node_map.parent.node.validate_parent_instance_node(instance_node, self)
 				# Hit top node
@@ -72,7 +76,7 @@ module ActiveRecordSurvey
 			# More complex....
 			# Recureses to the parent node to check
 			# This is to validate Node::Question since they don't have instance_nodes directly to validate them
-			parent_validations_passed = !self.node_maps.collect { |node_map|
+			parent_validations_passed = !self.survey.node_maps.select { |i| i.node == self}.collect { |node_map|
 				if node_map.parent
 					node_map.parent.node.validate_parent_instance_node(instance_node, self)
 				# Hit top node
@@ -96,7 +100,7 @@ module ActiveRecordSurvey
 
 			# Start at each node_map of this node
 			# Find the parent node ma
-			paths = self.node_maps.collect { |node_map|
+			paths = self.survey.node_maps.select { |i| i.node == self }.collect { |node_map|
 				# There is another level to traverse
 				if node_map.parent
 					node_map.parent.node.instance_node_path_to_root?(instance_node)

data/lib/active_record_survey/node_map.rb

@@ -7,33 +7,34 @@ module ActiveRecordSurvey
 
 		validates_presence_of :survey
 
-		after_initialize do |i|
-			# Required for all functions to work without creating
-			i.survey.node_maps << self if i.new_record? && i.survey
-		end
-
 		# Recursively creates a copy of this entire node_map
 		def recursive_clone
-			node_map = self.node.node_maps.build(:survey => self.survey, :node => self.node)
+			node_map = self.survey.node_maps.build(:survey => self.survey, :node => self.node)
 			self.children.each { |child_node|
+				child_node.survey = self.survey # required due to voodoo - we want to use the same survey with the same object_id
 				node_map.children << child_node.recursive_clone
 			}
 			node_map
 		end
 
-		def as_map(node_maps = nil)
-			children = (node_maps.nil?)? self.children : node_maps.select { |i|
-				i.parent == self
+		def as_map(options)
+			node_maps = options[:node_maps]
+
+			c = (node_maps.nil?)? self.children : node_maps.select { |i|
+				i.parent == self && !i.marked_for_destruction?
 			}
 
-			{
-				:id => self.id,
-				:node_id => self.node.id,
+			result = {}
+			result.merge!({ :id => self.id, :node_id => self.node.id }) if !options[:no_ids]
+			result.merge!({
 				:type => self.node.class.to_s,
-				:children => children.collect { |i|
-					i.as_map(node_maps)
+				:children => c.collect { |i|
+					i.as_map(options)
 				}
-			}
+			})
+			
+
+			result
 		end
 
 		# Gets all the child nodes until one is not an ancestor of klass
@@ -57,5 +58,14 @@ module ActiveRecordSurvey
 			}
 			false
 		end
+		
+		def mark_self_and_children_for_destruction
+			removed = [self]
+			self.mark_for_destruction
+			self.children.each { |i|
+				removed.concat(i.mark_self_and_children_for_destruction)
+			}
+			removed
+		end
 	end
 end

data/lib/active_record_survey/survey.rb

@@ -1,44 +1,21 @@
 module ActiveRecordSurvey
 	class Survey < ::ActiveRecord::Base
 		self.table_name = "active_record_surveys"
-		has_many :node_maps, :class_name => "ActiveRecordSurvey::NodeMap", :foreign_key => :active_record_survey_id
+		has_many :node_maps, :class_name => "ActiveRecordSurvey::NodeMap", :foreign_key => :active_record_survey_id, autosave: true
 		has_many :nodes, -> { distinct }, :through => :node_maps
-
-		def questions
-			self.node_maps.includes(:node).select { |i|
-				i.node.class.ancestors.include?(::ActiveRecordSurvey::Node::Question)
-			}.collect { |i|
-				i.node
-			}.uniq
-		end
+		has_many :questions, :class_name => "ActiveRecordSurvey::Node::Question", :foreign_key => :active_record_survey_id
 
 		def root_node
 			self.node_maps.includes(:node).select { |i| i.depth === 0 }.first
 		end
 
-		def as_map
-			list = self.node_maps
+		def as_map(*args)
+			options = args.extract_options!
+			options[:node_maps] ||= self.node_maps
 
-			list.select { |i| !i.parent }.collect { |i|
-				i.as_map(list)
+			self.node_maps.select { |i| !i.parent && !i.marked_for_destruction? }.collect { |i|
+				i.as_map(options)
 			}
 		end
-
-		# Build a question for this survey
-		def build_question(question)
-			# build_question only accepts a node that inherits from Question
-			if !question.class.ancestors.include?(::ActiveRecordSurvey::Node::Question)
-				raise ArgumentError.new "Question must inherit from ::ActiveRecordSurvey::Node::Question"
-			end
-
-			# Already added - shouldn't add twice
-			if question.node_maps.select { |node_map|
-				node_map.survey === self
-			}.length > 0
-				raise RuntimeError.new "This question has already been added to the survey"
-			end
-
-			question.node_maps.build(:node => question, :survey => self)
-		end
 	end
 end

data/lib/active_record_survey/version.rb

@@ -1,3 +1,3 @@
 module ActiveRecordSurvey
-	VERSION = "0.1.25"
+	VERSION = "0.1.26"
 end

data/lib/generators/active_record_survey/templates/migration_0.1.0.rb

@@ -25,6 +25,8 @@ class AddActiveRecordSurvey < ActiveRecord::Migration
 			t.integer :parent_id, :null => true, :index => true
 			t.integer :lft, :null => false, :index => true
 			t.integer :rgt, :null => false, :index => true
+
+			# optional fields
 			t.integer :depth, :null => false, :default => 0
 			t.integer :children_count, :null => false, :default => 0
 

data/lib/generators/active_record_survey/templates/migration_0.1.26.rb

@@ -0,0 +1,9 @@
+class Update_0_1_26_ActiveRecordSurvey < ActiveRecord::Migration
+	def self.up
+		add_column :active_record_survey_nodes, :active_record_survey_id, :integer
+	end
+
+	def self.down
+		remove_column :active_record_survey_nodes, :active_record_survey_id
+	end
+end

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

@@ -3,21 +3,20 @@ require 'spec_helper'
 describe ActiveRecordSurvey::Node::Answer::Boolean, :boolean_spec => true do
 	describe 'a boolean survey is' do
 		before(:all) do
-			@survey = ActiveRecordSurvey::Survey.new
-
-			@q1 = ActiveRecordSurvey::Node::Question.new()
-			@q1_a1 = ActiveRecordSurvey::Node::Answer::Boolean.new()
-			@q1_a2 = ActiveRecordSurvey::Node::Answer::Boolean.new()
-			@q1_a3 = ActiveRecordSurvey::Node::Answer::Boolean.new()
-			@q1_a4 = ActiveRecordSurvey::Node::Answer::Boolean.new()
-			@q1_a5 = ActiveRecordSurvey::Node::Answer::Boolean.new()
-
-			@survey.build_question(@q1)
-			@q1.build_answer(@q1_a1, @survey)
-			@q1.build_answer(@q1_a2, @survey)
-			@q1.build_answer(@q1_a3, @survey)
-			@q1.build_answer(@q1_a4, @survey)
-			@q1.build_answer(@q1_a5, @survey)
+			@survey = ActiveRecordSurvey::Survey.new()
+
+			@q1 = ActiveRecordSurvey::Node::Question.new(:text => "Q1", :survey => @survey)
+			@q1_a1 = ActiveRecordSurvey::Node::Answer::Boolean.new(:text => "A")
+			@q1_a2 = ActiveRecordSurvey::Node::Answer::Boolean.new(:text => "B")
+			@q1_a3 = ActiveRecordSurvey::Node::Answer::Boolean.new(:text => "C")
+			@q1_a4 = ActiveRecordSurvey::Node::Answer::Boolean.new(:text => "D")
+			@q1_a5 = ActiveRecordSurvey::Node::Answer::Boolean.new(:text => "E")
+
+			@q1.build_answer(@q1_a1)
+			@q1.build_answer(@q1_a2)
+			@q1.build_answer(@q1_a3)
+			@q1.build_answer(@q1_a4)
+			@q1.build_answer(@q1_a5)
 
 			@survey.save
 		end

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

@@ -5,19 +5,18 @@ describe ActiveRecordSurvey::Node::Answer::Rank, :rank_spec => true do
 		before(:all) do
 			@survey = ActiveRecordSurvey::Survey.new
 
-			@q1 = ActiveRecordSurvey::Node::Question.new()
+			@q1 = ActiveRecordSurvey::Node::Question.new(:survey => @survey)
 			@q1_a1 = ActiveRecordSurvey::Node::Answer::Rank.new()
 			@q1_a2 = ActiveRecordSurvey::Node::Answer::Rank.new()
 			@q1_a3 = ActiveRecordSurvey::Node::Answer::Rank.new()
 			@q1_a4 = ActiveRecordSurvey::Node::Answer::Rank.new()
 			@q1_a5 = ActiveRecordSurvey::Node::Answer::Rank.new()
 
-			@survey.build_question(@q1)
-			@q1.build_answer(@q1_a1, @survey)
-			@q1.build_answer(@q1_a2, @survey)
-			@q1.build_answer(@q1_a3, @survey)
-			@q1.build_answer(@q1_a4, @survey)
-			@q1.build_answer(@q1_a5, @survey)
+			@q1.build_answer(@q1_a1)
+			@q1.build_answer(@q1_a2)
+			@q1.build_answer(@q1_a3)
+			@q1.build_answer(@q1_a4)
+			@q1.build_answer(@q1_a5)
 
 			@survey.save
 		end