affectiva-surveyor 1.5.0.pre.disco.2

data/lib/surveyor/models/survey_methods.rb

@@ -0,0 +1,100 @@
+require 'surveyor/common'
+require 'rabl'
+
+module Surveyor
+  module Models
+    module SurveyMethods
+      def self.included(base)
+        # Associations
+        base.instance_eval {has_many :sections, ->{order "#{SurveySection.quoted_table_name}.display_order"}, :class_name => "SurveySection", :dependent => :destroy}
+        base.instance_eval {has_many :sections_with_questions, ->{includes(:questions).order("#{SurveySection.quoted_table_name}.display_order")}, :class_name => "SurveySection"}
+        base.send :has_many, :response_sets
+        base.send :has_many, :translations, :class_name => "SurveyTranslation"
+
+        # Scopes
+        base.instance_eval {scope :with_sections, ->{includes :sections}}
+
+        @@validations_already_included ||= nil
+        unless @@validations_already_included
+          # Validations
+          base.send :validates_presence_of, :title
+          base.send :validates_uniqueness_of, :survey_version, :scope => :access_code, :message => "survey with matching access code and version already exists"
+
+          @@validations_already_included = true
+        end
+
+        # Derived attributes
+        base.send :before_save, :generate_access_code
+        base.send :before_save, :increment_version
+
+        # Class methods
+        base.instance_eval do
+          def to_normalized_string(value)
+            # replace non-alphanumeric with "-". remove repeat "-"s. don't start or end with "-"
+            value.to_s.downcase.gsub(/[^a-z0-9]/,"-").gsub(/-+/,"-").gsub(/-$|^-/,"")
+          end
+        end
+      end
+
+      # Instance methods
+      def initialize(*args)
+        super(*args)
+        default_args
+      end
+
+      def default_args
+        self.api_id ||= Surveyor::Common.generate_api_id
+        self.display_order ||= Survey.count
+      end
+
+      def active?
+        self.active_as_of?(DateTime.now)
+      end
+      def active_as_of?(date)
+        (active_at && active_at < date && (!inactive_at || inactive_at > date)) ? true : false
+      end
+      def activate!
+        self.active_at = DateTime.now
+        self.inactive_at = nil
+      end
+      def deactivate!
+        self.inactive_at = DateTime.now
+        self.active_at = nil
+      end
+
+      def as_json(options = nil)
+        template_paths = ActionController::Base.view_paths.collect(&:to_path)
+        Rabl.render(filtered_for_json, 'surveyor/export.json', :view_path => template_paths, :format => "hash")
+      end
+
+      ##
+      # A hook that allows the survey object to be modified before it is
+      # serialized by the #as_json method.
+      def filtered_for_json
+        self
+      end
+
+      def default_access_code
+        self.class.to_normalized_string(title)
+      end
+
+      def generate_access_code
+        self.access_code ||= default_access_code
+      end
+
+      def increment_version
+        surveys = self.class.select(:survey_version).where(:access_code => access_code).order("survey_version DESC")
+        next_version = surveys.any? ? surveys.first.survey_version.to_i + 1 : 0
+
+        self.survey_version = next_version
+      end
+
+      def translation(locale_symbol)
+        t = self.translations.where(:locale => locale_symbol.to_s).first
+        {:title => self.title, :description => self.description}.with_indifferent_access.merge(
+          t ? YAML.load(t.translation || "{}").with_indifferent_access : {}
+        )
+      end
+    end
+  end
+end

data/lib/surveyor/models/survey_section_methods.rb

@@ -0,0 +1,53 @@
+module Surveyor
+  module Models
+    module SurveySectionMethods
+      def self.included(base)
+        # Associations
+        base.send :has_many, :questions, :dependent => :destroy
+        base.send :belongs_to, :survey
+
+        # Scopes
+        base.instance_eval {scope :with_includes, ->{ includes :questions => [:answers, :question_group, {:dependency => :dependency_conditions}]}}
+
+        @@validations_already_included ||= nil
+        unless @@validations_already_included
+          # Validations
+          base.send :validates_presence_of, :title, :display_order
+          # this causes issues with building and saving
+          #, :survey
+
+          @@validations_already_included = true
+        end
+      end
+
+      # Instance Methods
+      def initialize(*args)
+        super(*args)
+        default_args
+      end
+
+      def default_args
+        self.data_export_identifier ||= Surveyor::Common.normalize(title)
+      end
+
+      def questions_and_groups
+        qs = []
+        questions.each_with_index.map do |q,i|
+          if q.part_of_group?
+            if (i+1 >= questions.size) or (q.question_group_id != questions[i+1].question_group_id)
+              q.question_group
+            end
+          else
+            q
+          end
+        end.compact
+      end
+
+      def translation(locale)
+        {:title => self.title, :description => self.description}.with_indifferent_access.merge(
+          (self.survey.translation(locale)[:survey_sections] || {})[self.reference_identifier] || {}
+        )
+      end
+    end
+  end
+end

data/lib/surveyor/models/survey_translation_methods.rb

@@ -0,0 +1,30 @@
+module Surveyor
+  module Models
+    module SurveyTranslationMethods
+      def self.included(base)
+        # Associations
+        base.send :belongs_to, :survey
+
+        @@validations_already_included ||= nil
+        unless @@validations_already_included
+          # Validations
+          base.send :validates_presence_of, :locale, :translation
+          base.send :validates_uniqueness_of, :locale, :scope => :survey_id
+          # this causes issues with building and saving
+          #, :survey
+
+          @@validations_already_included = true
+        end
+      end
+
+      # Instance Methods
+      def initialize(*args)
+        super(*args)
+        default_args
+      end
+
+      def default_args
+      end
+    end
+  end
+end

data/lib/surveyor/models/validation_condition_methods.rb

@@ -0,0 +1,54 @@
+module Surveyor
+  module Models
+    module ValidationConditionMethods
+      def self.included(base)
+        # Associations
+        base.send :belongs_to, :validation
+
+        # Scopes
+        @@validations_already_included ||= nil
+        unless @@validations_already_included
+          # Validations
+          base.send :validates_presence_of, :operator, :rule_key
+          base.send :validates_inclusion_of, :operator, :in => Surveyor::Common::OPERATORS
+          base.send :validates_uniqueness_of, :rule_key, :scope => :validation_id
+          # this causes issues with building and saving
+          # base.send :validates_numericality_of, :validation_id #, :question_id, :answer_id
+          
+          @@validations_already_included = true
+        end
+        
+        base.send :include, Surveyor::ActsAsResponse # includes "as" instance method
+
+        # Class methods
+        base.instance_eval do
+          def operators
+            Surveyor::Common::OPERATORS
+          end
+        end
+      end
+
+      # Instance Methods
+      def to_hash(response)
+        {rule_key.to_sym => (response.nil? ? false : self.is_valid?(response))}
+      end
+
+      def is_valid?(response)
+        klass = response.answer.response_class
+        compare_to = Response.find_by_question_id_and_answer_id(self.question_id, self.answer_id) || self
+        case self.operator
+        when "==", "<", ">", "<=", ">="
+          response.as(klass).send(self.operator, compare_to.as(klass))
+        when "!="
+          !(response.as(klass) == compare_to.as(klass))
+        when "=~"
+          return false if compare_to != self
+          # SMELL Eval regex!!
+          !(response.as(klass).to_s =~ Regexp.new(eval(self.regexp) || "")).nil?
+        else
+          false
+        end
+      end
+    end
+  end
+end

data/lib/surveyor/models/validation_methods.rb

@@ -0,0 +1,45 @@
+module Surveyor
+  module Models
+    module ValidationMethods
+      def self.included(base)
+        # Associations
+        base.send :belongs_to, :answer
+        base.send :has_many, :validation_conditions, :dependent => :destroy
+
+        # Scopes
+        
+        @@validations_already_included ||= nil
+        unless @@validations_already_included
+          # Validations
+          base.send :validates_presence_of, :rule
+          base.send :validates_format_of, :rule, :with => /^(?:and|or|\)|\(|[A-Z]|\s)+$/, :multiline => true # SMELL with :multiline => true Rails reports a security risk
+          # this causes issues with building and saving
+          # base.send :validates_numericality_of, :answer_id
+          
+          @@validations_already_included = true
+        end
+      end
+
+      # Instance Methods
+      def is_valid?(response_set)
+        ch = conditions_hash(response_set)
+        rgx = Regexp.new(self.validation_conditions.map{|vc| ["a","o"].include?(vc.rule_key) ? "#{vc.rule_key}(?!nd|r)" : vc.rule_key}.join("|")) # exclude and, or
+        # logger.debug "v: #{self.inspect}"
+        # logger.debug "rule: #{self.rule.inspect}"
+        # logger.debug "rexp: #{rgx.inspect}"
+        # logger.debug "keyp: #{ch.inspect}"
+        # logger.debug "subd: #{self.rule.gsub(rgx){|m| ch[m.to_sym]}}"
+        eval(self.rule.gsub(rgx){|m| ch[m.to_sym]})
+      end
+
+      # A hash of the conditions (keyed by rule_key) and their evaluation (boolean) in the context of response_set
+      def conditions_hash(response_set)
+        hash = {}
+        response = response_set.responses.detect{|r| r.answer_id.to_i == self.answer_id.to_i}
+        # logger.debug "r: #{response.inspect}"
+        self.validation_conditions.each{|vc| hash.merge!(vc.to_hash(response))}
+        return hash
+      end
+    end
+  end
+end

data/lib/surveyor/mustache_context.rb

@@ -0,0 +1,11 @@
+module Surveyor
+  module MustacheContext
+    def in_context(text, context=nil)
+      case context
+      when NilClass then text
+      when Hash     then Mustache.render(text, context)
+      else               context.render(text)
+      end
+    end
+  end
+end

data/lib/surveyor/parser.rb

@@ -0,0 +1,427 @@
+%w(survey survey_translation survey_section question_group question dependency dependency_condition answer validation validation_condition).each {|model| require model }
+
+require 'yaml'
+
+module Surveyor
+  class ParserError < StandardError; end
+  class Parser
+    class << self; attr_accessor :options, :log end
+
+    # Attributes
+    attr_accessor :context
+
+    # Class methods
+    def self.parse_file(filename, options={})
+      self.parse(File.read(filename),{:filename => filename}.merge(options))
+    end
+    def self.parse(str, options={})
+      self.ensure_attrs
+      self.options = options
+      self.log[:source] = str
+      Surveyor::Parser.rake_trace "\n"
+      Surveyor::Parser.new.parse(str)
+      Surveyor::Parser.rake_trace "\n"
+    end
+    def self.ensure_attrs
+      self.options ||= {}
+      self.log ||= {}
+      self.log[:indent] ||= 0
+      self.log[:source] ||= ""
+    end
+    def self.rake_trace(str, indent_increment=0)
+      self.ensure_attrs
+      unless str.blank?
+        puts "#{' ' * self.log[:indent]}#{str}" if self.options[:trace] == true
+      end
+      self.log[:indent] += indent_increment
+    end
+    # from https://github.com/rails/rails/blob/master/actionpack/lib/action_view/template/error.rb#L81
+    def self.source_extract(line)
+      source_code = self.log[:source].split("\n")
+      radius = 3
+      start_on_line = [ line - radius - 1, 0 ].max
+      end_on_line   = [ line + radius - 1, source_code.length].min
+
+      return unless source_code = source_code[start_on_line..end_on_line]
+      line_counter = start_on_line
+      source_code.sum do |line|
+        line_counter += 1
+        "#{line_counter}: #{line}\n"
+      end
+    end
+    def self.raise_error(str, skip_trace = false)
+      self.ensure_attrs
+      line =  caller[1].split('/').last.split(':')[1].to_i
+
+      raise Surveyor::ParserError, "#{str}\n" if skip_trace
+      raise Surveyor::ParserError, "#{self.source_extract(line)}\nline \##{line}: #{str}\n"
+    end
+
+    # Instance methods
+    def initialize
+      self.context = {}
+    end
+    def parse(str)
+      instance_eval(str)
+      return context[:survey]
+    end
+    # This method_missing does all the heavy lifting for the DSL
+    def method_missing(missing_method, *args, &block)
+      method_name, reference_identifier = missing_method.to_s.split("_", 2)
+      type = full(method_name)
+      Surveyor::Parser.raise_error( "\"#{type}\" is not a surveyor method." )if !%w(survey survey_translation survey_section question_group question dependency dependency_condition answer validation validation_condition).include?(type)
+
+      Surveyor::Parser.rake_trace(reference_identifier.blank? ? "#{type} #{args.map(&:inspect).join ', '}" : "#{type}_#{reference_identifier} #{args.map(&:inspect).join ', '}",
+                                  block_models.include?(type) ? 2 : 0)
+
+      # check for blocks
+      Surveyor::Parser.raise_error "A #{type.humanize.downcase} should take a block" if block_models.include?(type) && !block_given?
+      Surveyor::Parser.raise_error "A #{type.humanize.downcase} doesn't take a block" if !block_models.include?(type) && block_given?
+
+      # parse and build
+      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)
+        if type == 'survey'
+          resolve_dependency_condition_references
+          resolve_question_correct_answers
+          report_lost_and_duplicate_references
+          report_missing_default_locale
+          Surveyor::Parser.rake_trace("", -2)
+          if context[:survey].save
+            Surveyor::Parser.rake_trace "Survey saved."
+          else
+            Surveyor::Parser.raise_error "Survey not saved: #{context[:survey].errors.full_messages.join(", ")}"
+          end
+        else
+          Surveyor::Parser.rake_trace("", -2)
+          context[type.to_sym].clear(context)
+        end
+      end
+    end
+
+    # Private methods
+    private
+
+    def full(method_name)
+      case method_name.to_s
+      when /^translations$/; "survey_translation"
+      when /^section$/; "survey_section"
+      when /^g$|^grid$|^group$|^repeater$/; "question_group"
+      when /^q$|^label$|^image$/; "question"
+      when /^a$/; "answer"
+      when /^d$/; "dependency"
+      when /^c(ondition)?$/; context[:validation] ? "validation_condition" : "dependency_condition"
+      when /^v$/; "validation"
+      when /^dc(ondition)?$/; "dependency_condition"
+      when /^vc(ondition)?$/; "validation_condition"
+      else method_name
+      end
+    end
+    def block_models
+      %w(survey survey_section question_group)
+    end
+    def report_missing_default_locale
+      if !self.context[:survey].translations.empty? && self.context[:survey].translations.select{|t|YAML::load(t.translation)=={}}.empty?
+        Surveyor::Parser.raise_error("No default locale specified for translations.",true)
+      end
+    end
+    def report_lost_and_duplicate_references
+      Surveyor::Parser.raise_error("Bad references: #{self.context[:bad_references].join("; ")}", true) unless self.context[:bad_references].empty?
+      Surveyor::Parser.raise_error("Duplicate references: #{self.context[:duplicate_references].join("; ")}", true) 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
+
+# Survey model
+module SurveyorParserSurveyMethods
+  def parse_and_build(context, args, original_method, reference_identifier)
+    # clear context
+    clear(context)
+
+    # build and set context
+    title = args[0]
+    args[1] ||= {}
+    context[:default_mandatory] = args[1].delete(:default_mandatory) || false
+    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.merge!({
+      :question_references => {},
+      :answer_references => {},
+      :bad_references => [],
+      :duplicate_references => [],
+      :dependency_conditions => [],
+      :questions_with_correct_answers => {},
+      :default_mandatory => false
+    })
+  end
+end
+
+# SurveySection model
+module SurveyorParserSurveyTranslationMethods
+  def parse_and_build(context, args, original_method, reference_identifier)
+    dir = Surveyor::Parser.options[:filename].nil? ? Dir.pwd : File.dirname(Surveyor::Parser.options[:filename])
+    # build, no change in context
+    args[0].each do |k,v|
+      case v
+      when Hash
+        trans = YAML::dump(v)
+      when String
+        trans = File.read(File.join(dir,v))
+      when :default
+        trans = YAML::dump({})
+      end
+      context[:survey].translations << self.class.new(:locale => k.to_s, :translation => trans)
+    end
+  end
+end
+
+# SurveySection model
+module SurveyorParserSurveySectionMethods
+  def parse_and_build(context, args, original_method, reference_identifier)
+    # clear context
+    clear(context)
+
+    # build and set context
+    title = args[0]
+    self.attributes = ({
+      :title => title,
+      :reference_identifier => reference_identifier,
+      :display_order => context[:survey].sections.size }.merge(args[1] || {}))
+    context[:survey].sections << context[:survey_section] = self
+  end
+  def clear(context)
+    [ :survey_section,
+      :question_group,
+      :grid_answers,
+      :question,
+      :dependency,
+      :dependency_condition,
+      :answer,
+      :validation,
+      :validation_condition ].each{|k| context.delete k}
+  end
+end
+
+# QuestionGroup model
+module SurveyorParserQuestionGroupMethods
+  def parse_and_build(context, args, original_method, reference_identifier)
+    # clear context
+    clear(context)
+
+    # build and set context
+    self.attributes = ({
+      :text => args[0] || "Question Group",
+      :reference_identifier => reference_identifier,
+      :display_type => (original_method =~ /grid|repeater/ ? original_method : "default")}.merge(args[1] || {}))
+    context[:question_group] = self
+  end
+  def clear(context)
+    [ :question_group,
+      :grid_answers,
+      :question,
+      :dependency,
+      :dependency_condition,
+      :answer,
+      :validation,
+      :validation_condition ].each{|k| context.delete k}
+    context[:grid_answers] = []
+  end
+end
+
+# Question model
+module SurveyorParserQuestionMethods
+  def parse_and_build(context, args, original_method, reference_identifier)
+    # clear context
+    [ :question,
+      :dependency,
+      :dependency_condition,
+      :answer,
+      :validation,
+      :validation_condition ].each{|k| context.delete k}
+
+    # build and set context
+    text = args[0] || "Question"
+    hash_args = args[1] || {}
+    correct = hash_args.delete :correct
+    self.attributes = ({
+      :question_group => context[:question_group],
+      :reference_identifier => reference_identifier,
+      :is_mandatory => context[:default_mandatory],
+      :text => text,
+      :display_type => (original_method =~ /label|image/ ? original_method : "default"),
+      :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
+    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.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
+end
+
+# Dependency model
+module SurveyorParserDependencyMethods
+  def parse_and_build(context, args, original_method, reference_identifier)
+    # clear context
+    [ :dependency,
+      :dependency_condition ].each{|k| context.delete k}
+
+    # build and set context
+    self.attributes = (args[0] || {})
+    if context[:question]
+      context[:dependency] = context[:question].dependency = self
+    elsif context[:question_group]
+      context[:dependency] = context[:question_group].dependency = self
+    end
+  end
+end
+
+# DependencyCondition model
+module SurveyorParserDependencyConditionMethods
+  DependencyCondition.instance_eval do
+    attr_accessor :question_reference, :answer_reference
+  end
+  def parse_and_build(context, args, original_method, reference_identifier)
+    # clear context
+    context.delete :dependency_condition
+
+    # build and set context
+    a0, a1, a2 = args
+    self.attributes = ({
+      :operator => a1 || "==",
+      :question_reference => a0.to_s.gsub(/^q_|^question_/, ""),
+      :rule_key => reference_identifier
+    }.merge( a2.is_a?(Hash) ? a2 : { :answer_reference => a2.to_s.gsub(/^a_|^answer_/, "") }))
+    context[:dependency].dependency_conditions << context[:dependency_condition] = self
+    context[:dependency_conditions] << self
+  end
+end
+
+# Answer model
+module SurveyorParserAnswerMethods
+  def parse_and_build(context, args, original_method, reference_identifier)
+    # clear context
+    [ :answer,
+      :validation,
+      :validation_condition ].each{|k| context.delete k}
+    attrs = { :reference_identifier => reference_identifier }.merge(parse_args(args))
+
+    # add answers to grid
+    if context[:question_group] && context[:question_group].display_type == "grid"
+      self.attributes = ({:display_order => context[:grid_answers].size}.merge(attrs))
+      context[:grid_answers] << context[:answer] = self
+    else
+      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 self.reference_identifier.blank?
+        context[:answer_references][context[:question].reference_identifier] ||= {}
+        context[:duplicate_references].push "q_#{context[:question].reference_identifier}, a_#{self.reference_identifier}" if context[:answer_references][context[:question].reference_identifier].has_key?(self.reference_identifier)
+        context[:answer_references][context[:question].reference_identifier][self.reference_identifier] = context[:answer]
+      end
+    end
+  end
+  def parse_args(args)
+    case args[0]
+    when Hash # Hash
+      text_args(args[0][:text]).merge(args[0])
+    when String # (String, Hash) or (String, Symbol, Hash)
+      text_args(args[0]).merge(hash_from args[1]).merge(args[2] || {})
+    when Symbol # (Symbol, Hash) or (Symbol, Symbol, Hash)
+      symbol_args(args[0]).merge(hash_from args[1]).merge(args[2] || {})
+    else
+      text_args(nil)
+    end
+  end
+  def text_args(text = "Answer")
+    {:text => text.to_s}
+  end
+  def hash_from(arg)
+    arg.is_a?(Symbol) ? {:response_class => arg.to_s} : arg.is_a?(Hash) ? arg : {}
+  end
+  def symbol_args(arg)
+    case arg
+    when :other
+      text_args("Other")
+    when :other_and_string
+      text_args("Other").merge({:response_class => "string"})
+    when :none, :omit # is_exclusive erases and disables other checkboxes and input elements
+      text_args(arg.to_s.humanize).merge({:is_exclusive => true})
+    when :integer, :float, :date, :time, :datetime, :text, :datetime, :string
+      text_args(arg.to_s.humanize).merge({:response_class => arg.to_s, :display_type => "hidden_label"})
+    end
+  end
+end
+
+# 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
+    self.attributes = ({:rule => "A"}.merge(args[0] || {}))
+    context[:answer].validations << context[:validation] = self
+  end
+end
+
+# ValidationCondition model
+module SurveyorParserValidationConditionMethods
+  def parse_and_build(context, args, original_method, reference_identifier)
+    # clear context
+    context.delete :validation_condition
+
+    # build and set context
+    a0, a1 = args
+    self.attributes = ({
+      :operator => a0 || "==",
+      :rule_key => reference_identifier}.merge(a1 || {}))
+    context[:validation].validation_conditions << context[:validation_condition] = self
+  end
+end