surveyor 0.22.0 → 1.0.0

data/lib/surveyor/parser.rb

@@ -1,8 +1,9 @@
 %w(survey survey_section question_group question dependency dependency_condition answer validation validation_condition).each {|model| require model }
 module Surveyor
+  class ParserError < StandardError; end
   class Parser
     class << self; attr_accessor :options end
-    
+
     # Attributes
     attr_accessor :context
 
@@ -17,7 +18,7 @@ module Surveyor
       self.options ||= {}
       print str if self.options[:trace] == true
     end
-    
+
     # Instance methods
     def initialize
       self.context = {}
@@ -30,27 +31,31 @@ module Surveyor
     def method_missing(missing_method, *args, &block)
       method_name, reference_identifier = missing_method.to_s.split("_", 2)
       type = full(method_name)
-      
+
       Surveyor::Parser.rake_trace reference_identifier.blank? ? "#{type} " : "#{type}_#{reference_identifier} "
-      
+
       # check for blocks
-      raise "Error: A #{type.humanize} cannot be empty" if block_models.include?(type) && !block_given?
-      raise "Error: Dropping the #{type.humanize} block like it's hot!" if !block_models.include?(type) && block_given?
-      
+      raise Surveyor::ParserError, "Error: A #{type.humanize} cannot be empty" if block_models.include?(type) && !block_given?
+      raise Surveyor::ParserError, "Error: Dropping the #{type.humanize} block like it's hot!" if !block_models.include?(type) && block_given?
+
       # parse and build
-      type.classify.constantize.parse_and_build(context, args, method_name, reference_identifier)
-      
+      type.classify.constantize.new.extend("SurveyorParser#{type.classify}Methods".constantize).parse_and_build(context, args, method_name, reference_identifier)
+
       # evaluate and clear context for block models
       if block_models.include?(type)
-        self.instance_eval(&block) 
+        self.instance_eval(&block)
         if type == 'survey'
+          resolve_dependency_condition_references
+          resolve_question_correct_answers
+          report_lost_and_duplicate_references
           Surveyor::Parser.rake_trace "\n"
-          Surveyor::Parser.rake_trace context[type.to_sym].save ? "saved. " : " not saved! #{context[type.to_sym].errors.each_full{|x| x }.join(", ")} "
+          Surveyor::Parser.rake_trace context[:survey].save ? "saved. " : " not saved! #{context[type.to_sym].errors.each_full{|x| x }.join(", ")} "
+        else
+          context[type.to_sym].clear(context)
         end
-        context[type.to_sym].clear(context) unless type == 'survey'
       end
     end
-    
+
     # Private methods
     private
 
@@ -71,228 +76,273 @@ module Surveyor
     def block_models
       %w(survey survey_section question_group)
     end
+    def report_lost_and_duplicate_references
+      raise Surveyor::ParserError, "Bad references: #{self.context[:bad_references].join("; ")}" unless self.context[:bad_references].empty?
+      raise Surveyor::ParserError, "Duplicate references: #{self.context[:duplicate_references].join("; ")}" unless self.context[:duplicate_references].empty?
+    end
+    def resolve_question_correct_answers
+      self.context[:questions_with_correct_answers].each do |question_reference_idenitifer, correct_answer_reference|
+        # Looking up references for quiz answers
+        if self.context[:answer_references][question_reference_idenitifer] &&
+             (a = self.context[:answer_references][question_reference_idenitifer][correct_answer_reference]) &&
+             a.save
+          self.context[:question_references][question_reference_idenitifer].correct_answer_id = a.id
+        else
+          self.context[:bad_references].push "q_#{question_reference_idenitifer}.correct => a_#{correct_answer_reference}"
+        end
+      end
+    end
+    def resolve_dependency_condition_references
+      self.context[:dependency_conditions].each do |dc|
+        # Looking up references to questions and answers for linking the dependency objects
+        self.context[:bad_references].push "q_#{dc.question_reference}" unless (dc.question = self.context[:question_references][dc.question_reference])
+        self.context[:answer_references][dc.question_reference] ||= {}
+        self.context[:bad_references].push "q_#{dc.question_reference}, a_#{dc.answer_reference}" if !dc.answer_reference.blank? and (dc.answer = self.context[:answer_references][dc.question_reference][dc.answer_reference]).nil?
+      end
+    end
   end
 end
 
 # Surveyor models with extra parsing methods
-class Survey < ActiveRecord::Base
-  # block
-  
-  def self.parse_and_build(context, args, original_method, reference_identifier)
+
+# Survey model
+module SurveyorParserSurveyMethods
+  def parse_and_build(context, args, original_method, reference_identifier)
     # clear context
-    context.delete_if{|k,v| true }
-    context[:question_references] = {}
-    context[:answer_references] = {}
-    
+    clear(context)
+
     # build and set context
     title = args[0]
-    context[:survey] = new({  :title => title, 
-                              :reference_identifier => reference_identifier }.merge(args[1] || {}))
+    self.attributes = ({
+      :title => title,
+      :reference_identifier => reference_identifier }.merge(args[1] || {}))
+    context[:survey] = self
   end
   def clear(context)
-    context.delete_if{|k,v| true }
-    context[:question_references] = {}
-    context[:answer_references] = {}
+    context.delete_if{|k,v| true}
+    context.merge!({
+      :question_references => {},
+      :answer_references => {},
+      :bad_references => [],
+      :duplicate_references => [],
+      :dependency_conditions => [],
+      :questions_with_correct_answers => {} })
   end
 end
-class SurveySection < ActiveRecord::Base
-  # block
-  
-  def self.parse_and_build(context, args, original_method, reference_identifier)
+
+# SurveySection model
+module SurveyorParserSurveySectionMethods
+  def parse_and_build(context, args, original_method, reference_identifier)
     # clear context
-    context.delete_if{|k,v| !%w(survey question_references answer_references).map(&:to_sym).include?(k)}
-    
+    clear(context)
+
     # build and set context
     title = args[0]
-    context[:survey_section] = context[:survey].sections.build({ :title => title,
-                                                                 :display_order => context[:survey].sections.size }.merge(args[1] || {}))
+    self.attributes = ({
+      :title => title,
+      :display_order => context[:survey].sections.size }.merge(args[1] || {}))
+    context[:survey].sections << context[:survey_section] = self
   end
   def clear(context)
-    context.delete_if{|k,v| !%w(survey question_references answer_references).map(&:to_sym).include?(k)}
+    [ :survey_section,
+      :question_group,
+      :question,
+      :dependency,
+      :dependency_condition,
+      :answer,
+      :validation,
+      :validation_condition ].each{|k| context.delete k}
   end
 end
-class QuestionGroup < ActiveRecord::Base
-  # block
-  
-  def self.parse_and_build(context, args, original_method, reference_identifier)
+
+# QuestionGroup model
+module SurveyorParserQuestionGroupMethods
+  def parse_and_build(context, args, original_method, reference_identifier)
     # clear context
-    context.delete_if{|k,v| !%w(survey survey_section question_references answer_references).map(&:to_sym).include?(k)}
-    
-    # build and set context
-    context[:question_group] = context[:question_group] = new({  :text => args[0] || "Question Group",
-                                      :display_type => (original_method =~ /grid|repeater/ ? original_method : "default")}.merge(args[1] || {}))
+    clear(context)
 
+    # build and set context
+    self.attributes = ({
+      :text => args[0] || "Question Group",
+      :display_type => (original_method =~ /grid|repeater/ ? original_method : "default")}.merge(args[1] || {}))
+    context[:question_group] = self
   end
   def clear(context)
-    context.delete_if{|k,v| !%w(survey survey_section question_references answer_references).map(&:to_sym).include?(k)}
+    [ :question_group,
+      :question,
+      :dependency,
+      :dependency_condition,
+      :answer,
+      :validation,
+      :validation_condition ].each{|k| context.delete k}
   end
 end
-class Question < ActiveRecord::Base
-  # nonblock
-  
-  # attributes
-  attr_accessor :correct, :context_reference
-  before_save :resolve_correct_answers
-  
-  def self.parse_and_build(context, args, original_method, reference_identifier)
+
+# Question model
+module SurveyorParserQuestionMethods
+  def parse_and_build(context, args, original_method, reference_identifier)
     # clear context
-    context.delete_if{|k,v| %w(question dependency dependency_condition answer validation validation_condition).map(&:to_sym).include? k}
-    
+    [ :question,
+      :dependency,
+      :dependency_condition,
+      :answer,
+      :validation,
+      :validation_condition ].each{|k| context.delete k}
+
     # build and set context
     text = args[0] || "Question"
-    context[:question] = context[:survey_section].questions.build({
-      :context_reference => context,
+    hash_args = args[1] || {}
+    correct = hash_args.delete :correct
+    self.attributes = ({
       :question_group => context[:question_group],
       :reference_identifier => reference_identifier,
       :text => text,
       :display_type => (original_method =~ /label|image/ ? original_method : "default"),
-      :display_order => context[:survey_section].questions.size }.merge(args[1] || {}))
-    
+      :display_order => context[:survey_section].questions.size }.merge(hash_args))
+    context[:survey_section].questions << context[:question] = self
+
+    # keep reference for correct answers
+    context[:questions_with_correct_answers][self.reference_identifier] = correct unless self.reference_identifier.blank? or correct.blank?
+
     # keep reference for dependencies
-    context[:question_references][reference_identifier] = context[:question] unless reference_identifier.blank?
-    
+    unless self.reference_identifier.blank?
+      context[:duplicate_references].push "q_#{self.reference_identifier}" if context[:question_references].has_key?(self.reference_identifier)
+      context[:question_references][self.reference_identifier] = context[:question]
+    end
+
     # add grid answers
     if context[:question_group] && context[:question_group].display_type == "grid"
       (context[:grid_answers] || []).each do |grid_answer|
-        a = context[:question].answers.build(grid_answer.attributes)
-        context[:answer_references][reference_identifier] ||= {} unless reference_identifier.blank?
-        context[:answer_references][reference_identifier][grid_answer.reference_identifier] = a unless reference_identifier.blank? or grid_answer.reference_identifier.blank?
+        a = context[:question].answers.build(grid_answer.attributes.reject{|k,v| %w(id api_id created_at updated_at).include?(k)})
+        context[:answer_references][self.reference_identifier] ||= {} unless self.reference_identifier.blank?
+        context[:answer_references][self.reference_identifier][grid_answer.reference_identifier] = a unless self.reference_identifier.blank? or grid_answer.reference_identifier.blank?
       end
     end
   end
-  
-  def resolve_correct_answers
-    unless correct.blank? or reference_identifier.blank? or context_reference.blank?
-      # Looking up references for quiz answers
-      context_reference[:answer_references][reference_identifier] ||= {}
-      Surveyor::Parser.rake_trace( (self.correct_answer = context_reference[:answer_references][reference_identifier][correct]) ? "found correct answer:#{correct} " : "lost! correct answer:#{correct} ")
-    end
-  end
 end
-class Dependency < ActiveRecord::Base
-  # nonblock
-  
-  def self.parse_and_build(context, args, original_method, reference_identifier)
+
+# Dependency model
+module SurveyorParserDependencyMethods
+  def parse_and_build(context, args, original_method, reference_identifier)
     # clear context
-    context.delete_if{|k,v| %w(dependency dependency_condition).map(&:to_sym).include? k}
-    
+    [ :dependency,
+      :dependency_condition ].each{|k| context.delete k}
+
     # build and set context
+    self.attributes = (args[0] || {})
     if context[:question]
-      context[:dependency] = context[:question].build_dependency(args[0] || {})
+      context[:dependency] = context[:question].dependency = self
     elsif context[:question_group]
-      context[:dependency] = context[:question_group].build_dependency(args[0] || {})
+      context[:dependency] = context[:question_group].dependency = self
     end
   end
 end
-class DependencyCondition < ActiveRecord::Base
-  # nonblock
-  
-  attr_accessor :question_reference, :answer_reference, :context_reference
-  before_save :resolve_references
-  
-  def self.parse_and_build(context, args, original_method, reference_identifier)
+
+# DependencyCondition model
+module SurveyorParserDependencyConditionMethods
+  DependencyCondition.instance_eval do
+    attr_accessor :question_reference, :answer_reference
+    attr_accessible :question_reference, :answer_reference
+  end
+  def parse_and_build(context, args, original_method, reference_identifier)
     # clear context
-    context.delete_if{|k,v| k == :dependency_condition}
-    
+    context.delete :dependency_condition
+
     # build and set context
     a0, a1, a2 = args
-    context[:dependency_condition] = context[:dependency].
-      dependency_conditions.build(
-        { 
-          :context_reference => context,
-          :operator => a1 || "==",
-          :question_reference => a0.to_s.gsub(/^q_/, ""),
-          :rule_key => reference_identifier 
-        }.merge(
-            a2.is_a?(Hash) ? a2 : { :answer_reference => 
-                                      a2.to_s.gsub(/^a_/, "") }
-          )
-      )
-  end
-
-  def resolve_references
-    if context_reference
-      # Looking up references to questions and answers for linking the dependency objects
-      Surveyor::Parser.rake_trace( (self.question = context_reference[:question_references][question_reference]) ? "found question:#{question_reference} " : "lost! question:#{question_reference} ")
-      context_reference[:answer_references][question_reference] ||= {}
-      Surveyor::Parser.rake_trace( (self.answer = context_reference[:answer_references][question_reference][answer_reference]) ? "found answer:#{answer_reference} " : "lost! answer:#{answer_reference} ")
-    end
+    self.attributes = ({
+      :operator => a1 || "==",
+      :question_reference => a0.to_s.gsub(/^q_/, ""),
+      :rule_key => reference_identifier
+    }.merge( a2.is_a?(Hash) ? a2 : { :answer_reference => a2.to_s.gsub(/^a_/, "") }))
+    context[:dependency].dependency_conditions << context[:dependency_condition] = self
+    context[:dependency_conditions] << self
   end
 end
 
-class Answer < ActiveRecord::Base
-  # nonblock
-  
-  def self.parse_and_build(context, args, original_method, reference_identifier)
+# Answer model
+module SurveyorParserAnswerMethods
+  def parse_and_build(context, args, original_method, reference_identifier)
     # clear context
-    context.delete_if{|k,v| %w(answer validation validation_condition reference_identifier).map(&:to_sym).include? k}
+    [ :answer,
+      :validation,
+      :validation_condition ].each{|k| context.delete k}
+    attrs = { :reference_identifier => reference_identifier }.merge(parse_args(args))
 
-    attrs = { :reference_identifier => reference_identifier }.merge(self.parse_args(args))
-                              
     # add answers to grid
     if context[:question_group] && context[:question_group].display_type == "grid"
-      context[:grid_answers] ||= []      
-      context[:answer] = new({:display_order => [:grid_answers].size}.merge(attrs))
-      context[:grid_answers] << context[:answer]
+      context[:grid_answers] ||= []
+      self.attributes = ({:display_order => [:grid_answers].size}.merge(attrs))
+      context[:grid_answers] << context[:answer] = self
     else
-      context[:answer] = context[:question].answers.build({:display_order => context[:question].answers.size}.merge(attrs))
-      context[:answer_references][context[:question].reference_identifier] ||= {} unless context[:question].reference_identifier.blank?
-      context[:answer_references][context[:question].reference_identifier][reference_identifier] = context[:answer] unless reference_identifier.blank? or context[:question].reference_identifier.blank?
+      self.attributes = ({:display_order => context[:question].answers.size}.merge(attrs))
+      context[:question].answers << context[:answer] = self
+      # keep reference for dependencies
+      unless context[:question].reference_identifier.blank? or reference_identifier.blank?
+        context[:answer_references][context[:question].reference_identifier] ||= {}
+        context[:duplicate_references].push "q_#{context[:question].reference_identifier}, a_#{reference_identifier}" if context[:answer_references][context[:question].reference_identifier].has_key?(reference_identifier)
+        context[:answer_references][context[:question].reference_identifier][reference_identifier] = context[:answer]
+      end
     end
   end
-  def self.parse_args(args)
+  def parse_args(args)
     case args[0]
     when Hash # Hash
-      self.text_args(args[0][:text]).merge(args[0])
+      text_args(args[0][:text]).merge(args[0])
     when String # (String, Hash) or (String, Symbol, Hash)
-      self.text_args(args[0]).merge(self.hash_from args[1]).merge(args[2] || {})
+      text_args(args[0]).merge(hash_from args[1]).merge(args[2] || {})
     when Symbol # (Symbol, Hash) or (Symbol, Symbol, Hash)
-      self.symbol_args(args[0]).merge(self.hash_from args[1]).merge(args[2] || {})
+      symbol_args(args[0]).merge(hash_from args[1]).merge(args[2] || {})
     else
-      self.text_args(nil)
+      text_args(nil)
     end
   end
-  def self.text_args(text = "Answer")
+  def text_args(text = "Answer")
     {:text => text.to_s}
   end
-  def self.hash_from(arg)
+  def hash_from(arg)
     arg.is_a?(Symbol) ? {:response_class => arg.to_s} : arg.is_a?(Hash) ? arg : {}
   end
-  def self.symbol_args(arg)
+  def symbol_args(arg)
     case arg
     when :other
-      self.text_args("Other")
+      text_args("Other")
     when :other_and_string
-      self.text_args("Other").merge({:response_class => "string"})
+      text_args("Other").merge({:response_class => "string"})
     when :none, :omit # is_exclusive erases and disables other checkboxes and input elements
-      self.text_args(arg.to_s.humanize).merge({:is_exclusive => true})
+      text_args(arg.to_s.humanize).merge({:is_exclusive => true})
     when :integer, :float, :date, :time, :datetime, :text, :datetime, :string
-      self.text_args(arg.to_s.humanize).merge({:response_class => arg.to_s, :display_type => "hidden_label"})
+      text_args(arg.to_s.humanize).merge({:response_class => arg.to_s, :display_type => "hidden_label"})
     end
   end
 end
-class Validation < ActiveRecord::Base
-  # nonblock
-  
-  def self.parse_and_build(context, args, original_method, reference_identifier)
+
+# Validation model
+module SurveyorParserValidationMethods
+  def parse_and_build(context, args, original_method, reference_identifier)
     # clear context
+    [ :validation,
+      :validation_condition ].each{|k| context.delete k}
+
     context.delete_if{|k,v| %w(validation validation_condition).map(&:to_sym).include? k}
 
     # build and set context
-    context[:validation] = context[:answer].validations.build({:rule => "A"}.merge(args[0] || {}))
+    self.attributes = ({:rule => "A"}.merge(args[0] || {}))
+    context[:answer].validations << context[:validation] = self
   end
 end
-class ValidationCondition < ActiveRecord::Base
-  # nonblock
-  
-  def self.parse_and_build(context, args, original_method, reference_identifier)
+
+# ValidationCondition model
+module SurveyorParserValidationConditionMethods
+  def parse_and_build(context, args, original_method, reference_identifier)
     # clear context
-    context.delete_if{|k,v| k == :validation_condition}
+    context.delete :validation_condition
 
     # build and set context
     a0, a1 = args
-    context[:validation_condition] = context[:validation].validation_conditions.build({
-                                      :operator => a0 || "==",
-                                      :rule_key => reference_identifier}.merge(a1 || {}))
+    self.attributes = ({
+      :operator => a0 || "==",
+      :rule_key => reference_identifier}.merge(a1 || {}))
+    context[:validation].validation_conditions << context[:validation_condition] = self
   end
 end