surveyor 0.14.4 → 0.14.5

data/lib/surveyor/common.rb

@@ -1,6 +1,7 @@
 module Surveyor
   class Common
     RAND_CHARS = [('a'..'z'), ('A'..'Z'), (0..9)].map{|r| r.to_a}.flatten.to_s
+    OPERATORS = %w(== != < > <= >=)
     
     class << self
       def make_tiny_code(len = 10)

data/lib/surveyor/models/answer_methods.rb

@@ -0,0 +1,25 @@
+module Surveyor
+  module Models
+    module AnswerMethods
+      def self.included(base)
+        # Associations
+        base.send :belongs_to, :question
+        base.send :has_many, :responses
+        base.send :has_many, :validations, :dependent => :destroy
+        
+        # Scopes
+        base.send :default_scope, :order => "display_order ASC"
+
+        # Validations
+        base.send :validates_presence_of, :text
+        base.send :validates_numericality_of, :question_id, :allow_nil => false, :only_integer => true
+      end
+
+      # Instance Methods
+      def renderer(q = question)  
+        r = [q.pick.to_s, self.response_class].compact.map(&:downcase).join("_")
+        r.blank? ? :default : r.to_sym
+      end
+    end
+  end
+end

data/lib/surveyor/models/dependency_condition_methods.rb

@@ -0,0 +1,47 @@
+module Surveyor
+  module Models
+    module DependencyConditionMethods
+      def self.included(base)
+        # Associations
+        base.send :belongs_to, :answer
+        base.send :belongs_to, :dependency
+        base.send :belongs_to, :dependent_question, :foreign_key => :question_id, :class_name => :question
+        base.send :belongs_to, :question
+
+        # Validations
+        base.send :validates_numericality_of, :dependency_id, :question_id, :answer_id
+        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 => :dependency_id
+
+        base.send :acts_as_response # includes "as" instance method
+
+        # Class methods
+        base.instance_eval do
+          def operators
+            Surveyor::Common::OPERATORS
+          end
+        end
+      end
+
+      # Instance methods
+      def to_hash(response_set)
+        response = response_set.responses.detect{|r| r.answer_id.to_i == self.answer_id.to_i} || false # eval("nil and false") => nil so return false if no response is found
+        {rule_key.to_sym => (response and self.is_met?(response))}
+      end
+
+      # Checks to see if the response passed in meets the dependency condition
+      def is_met?(response)
+        klass = response.answer.response_class
+        return case self.operator
+        when "==", "<", ">", "<=", ">="
+          response.as(klass).send(self.operator, self.as(klass))
+        when "!="
+          !(response.as(klass) == self.as(klass))
+        else
+          false
+        end
+      end
+    end
+  end
+end

data/lib/surveyor/models/dependency_methods.rb

@@ -0,0 +1,52 @@
+module Surveyor
+  module Models
+    module DependencyMethods
+      def self.included(base)
+        # Associations
+        base.send :belongs_to, :question
+        base.send :belongs_to, :question_group
+        base.send :has_many, :dependency_conditions, :dependent => :destroy
+
+        # Validations
+        base.send :validates_presence_of, :rule
+        base.send :validates_format_of, :rule, :with => /^(?:and|or|\)|\(|[A-Z]|\s)+$/ #TODO properly formed parenthesis etc.
+        base.send :validates_numericality_of, :question_id, :if => Proc.new { |d| d.question_group_id.nil? }
+        base.send :validates_numericality_of, :question_group_id, :if => Proc.new { |d| d.question_id.nil? }
+
+        # Attribute aliases
+        base.send :alias_attribute, :dependent_question_id, :question_id
+      end
+
+      # Instance Methods
+      def question_group_id=(i)
+        write_attribute(:question_id, nil) unless i.nil?
+        write_attribute(:question_group_id, i)
+      end
+
+      def question_id=(i)
+        write_attribute(:question_group_id, nil) unless i.nil?
+        write_attribute(:question_id, i) 
+      end
+
+      # Has this dependency has been met in the context of response_set?
+      # Substitutes the conditions hash into the rule and evaluates it
+      def is_met?(response_set)
+        ch = conditions_hash(response_set)
+        return false if ch.blank?
+        # 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]}}"
+        rgx = Regexp.new(self.dependency_conditions.map{|dc| ["a","o"].include?(dc.rule_key) ? "#{dc.rule_key}(?!nd|r)" : dc.rule_key}.join("|")) # exclude and, or
+        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 = {}
+        self.dependency_conditions.each{|dc| hash.merge!(dc.to_hash(response_set))}
+        return hash
+      end    
+    end
+  end
+end

data/lib/surveyor/models/question_group_methods.rb

@@ -0,0 +1,35 @@
+module Surveyor
+  module Models
+    module QuestionGroupMethods
+      def self.included(base)
+        # Associations
+        base.send :has_many, :questions
+        base.send :has_one, :dependency
+      end
+      
+      # Instance Methods
+      def initialize(*args)
+        super(*args)
+        default_args
+      end
+
+      def default_args
+        self.display_type ||= "inline"
+      end
+
+      def renderer
+        display_type.blank? ? :default : display_type.to_sym
+      end
+
+      def dependent?
+        self.dependency != nil
+      end
+      def triggered?(response_set)
+        dependent? ? self.dependency.is_met?(response_set) : true
+      end
+      def css_class(response_set)
+        [(dependent? ? "dependent" : nil), (triggered?(response_set) ? nil : "hidden"), custom_class].compact.join(" ")
+      end
+    end
+  end
+end

data/lib/surveyor/models/question_methods.rb

@@ -0,0 +1,55 @@
+module Surveyor
+  module Models
+    module QuestionMethods
+      def self.included(base)
+        # Associations
+        base.send :belongs_to, :survey_section
+        base.send :belongs_to, :question_group, :dependent => :destroy
+        base.send :has_many, :answers, :order => "display_order ASC", :dependent => :destroy # it might not always have answers
+        base.send :has_one, :dependency, :dependent => :destroy
+
+        # Scopes
+        base.send :default_scope, :order => "display_order ASC"
+
+        # Validations
+        base.send :validates_presence_of, :text, :survey_section_id, :display_order
+        base.send :validates_inclusion_of, :is_mandatory, :in => [true, false]
+      end
+
+      # Instance Methods
+      def initialize(*args)
+        super(*args)
+        default_args
+      end
+
+      def default_args
+        self.is_mandatory ||= true
+        self.display_type ||= "default"
+        self.pick ||= "none"
+      end
+
+      def mandatory?
+        self.is_mandatory == true
+      end
+
+      def dependent?
+        self.dependency != nil
+      end
+      def triggered?(response_set)
+        dependent? ? self.dependency.is_met?(response_set) : true
+      end
+      def css_class(response_set)
+        [(dependent? ? "dependent" : nil), (triggered?(response_set) ? nil : "hidden"), custom_class].compact.join(" ")
+      end
+
+      def part_of_group?
+        !self.question_group.nil?
+      end
+
+      def renderer(g = question_group)
+        r = [g ? g.renderer.to_s : nil, display_type].compact.join("_")
+        r.blank? ? :default : r.to_sym
+      end
+    end
+  end
+end

data/lib/surveyor/models/response_methods.rb

@@ -0,0 +1,40 @@
+module Surveyor
+  module Models
+    module ResponseMethods
+      def self.included(base)
+        # Associations
+        base.send :belongs_to, :response_set
+        base.send :belongs_to, :question
+        base.send :belongs_to, :answer
+
+        # Validations
+        base.send :validates_presence_of, :response_set_id, :question_id, :answer_id
+
+        base.send :acts_as_response # includes "as" instance method
+      end
+
+      # Instance Methods
+      def selected
+        !self.new_record?
+      end
+
+      alias_method :selected?, :selected
+
+      def selected=(value)
+        true
+      end
+
+      def correct?
+        question.correct_answer_id.nil? or self.answer.response_class != "answer" or (question.correct_answer_id.to_i == answer_id.to_i)
+      end
+
+      def to_s # used in dependency_explanation_helper
+        if self.answer.response_class == "answer" and self.answer_id
+          return self.answer.text
+        else
+          return "#{(self.string_value || self.text_value || self.integer_value || self.float_value || nil).to_s}"
+        end
+      end
+    end
+  end
+end

data/lib/surveyor/models/response_set_methods.rb

@@ -0,0 +1,174 @@
+module Surveyor
+  module Models
+    module ResponseSetMethods
+      def self.included(base)
+        # Associations
+        base.send :belongs_to, :survey
+        base.send :belongs_to, :user
+        base.send :has_many, :responses, :dependent => :destroy
+
+        # Validations
+        base.send :validates_presence_of, :survey_id
+        base.send :validates_associated, :responses
+        base.send :validates_uniqueness_of, :access_code
+
+        # Attributes
+        base.send :attr_protected, :completed_at
+        base.send :attr_accessor, :current_section_id
+
+        # Callbacks
+        base.send :after_update, :save_responses
+      end
+
+      # Instance methods
+      def initialize(*args)
+        super(*args)
+        default_args
+      end
+
+      def default_args
+        self.started_at ||= Time.now
+        self.access_code = Surveyor::Common.make_tiny_code
+      end
+
+      def access_code=(val)
+        while ResponseSet.find_by_access_code(val)
+          val = Surveyor::Common.make_tiny_code
+        end
+        super
+      end
+
+      def to_csv
+        qcols = Question.content_columns.map(&:name) - %w(created_at updated_at)
+        acols = Answer.content_columns.map(&:name) - %w(created_at updated_at)
+        rcols = Response.content_columns.map(&:name)
+        require 'fastercsv'
+        FCSV(result = "") do |csv|
+          csv << qcols.map{|qcol| "question.#{qcol}"} + acols.map{|acol| "answer.#{acol}"} + rcols.map{|rcol| "response.#{rcol}"}
+          responses.each do |response|
+            csv << qcols.map{|qcol| response.question.send(qcol)} + acols.map{|acol| response.answer.send(acol)} + rcols.map{|rcol| response.send(rcol)}
+          end
+        end
+        result
+      end
+
+      def response_for(question_id, answer_id, group = nil)
+        found = responses.detect{|r| r.question_id == question_id && r.answer_id == answer_id && r.response_group.to_s == group.to_s}
+        found.blank? ? responses.new(:question_id => question_id, :answer_id => answer_id, :response_group => group) : found
+      end
+
+      def clear_responses
+        question_ids = Question.find_all_by_survey_section_id(current_section_id).map(&:id)
+        responses.select{|r| question_ids.include? r.question_id}.map(&:destroy)
+        responses.reload
+      end
+
+      def response_attributes=(response_attributes)
+        response_attributes.each do |question_id, responses_hash|
+          # Response.delete_all(["response_set_id =? AND question_id =?", self.id, question_id])
+          if (answer_id = responses_hash[:answer_id]) 
+            if (!responses_hash[:answer_id].empty?) # Dropdowns return answer id but have an empty value if they are not set... ignoring those.
+              #radio or dropdown - only one response
+              responses.build({:question_id => question_id, :answer_id => answer_id, :survey_section_id => current_section_id}.merge(responses_hash[answer_id] || {}))
+            end
+          else
+            #possibly multiples responses - unresponded radios end up here too
+            # we use the variable question_id, not the "question_id" in the response_hash
+            responses_hash.delete_if{|k,v| k == "question_id"}.each do |answer_id, response_hash|
+              unless response_hash.delete_if{|k,v| v.blank?}.empty?
+                responses.build({:question_id => question_id, :answer_id => answer_id, :survey_section_id => current_section_id}.merge(response_hash))
+              end
+            end
+          end
+        end
+      end
+
+      def response_group_attributes=(response_attributes)
+        response_attributes.each do |question_id, responses_group_hash|
+          # Response.delete_all(["response_set_id =? AND question_id =?", self.id, question_id])
+          responses_group_hash.each do |response_group_number, group_hash|
+            if (answer_id = group_hash[:answer_id]) # if group_hash has an answer_id key we treat it differently 
+              if (!group_hash[:answer_id].empty?) # dropdowns return empty values in answer_ids if they are not selected
+                #radio or dropdown - only one response
+                responses.build({:question_id => question_id, :answer_id => answer_id, :response_group => response_group_number, :survey_section_id => current_section_id}.merge(group_hash[answer_id] || {}))
+              end
+            else
+              #possibly multiples responses - unresponded radios end up here too
+              # we use the variable question_id in the key, not the "question_id" in the response_hash... same with response_group key
+              group_hash.delete_if{|k,v| (k == "question_id") or (k == "response_group")}.each do |answer_id, inner_hash|
+                unless inner_hash.delete_if{|k,v| v.blank?}.empty?
+                  responses.build({:question_id => question_id, :answer_id => answer_id, :response_group => response_group_number, :survey_section_id => current_section_id}.merge(inner_hash))
+                end
+              end
+            end
+
+          end
+        end
+      end
+
+      def save_responses
+        responses.each{|response| response.save(false)}
+      end
+
+      def complete!
+        self.completed_at = Time.now
+      end
+
+      def correct?
+        responses.all?(&:correct?)
+      end
+      def correctness_hash
+        { :questions => survey.sections_with_questions.map(&:questions).flatten.compact.size,
+          :responses => responses.compact.size,
+          :correct => responses.find_all(&:correct?).compact.size
+        }
+      end
+      def mandatory_questions_complete?
+        progress_hash[:triggered_mandatory] == progress_hash[:triggered_mandatory_completed]
+      end
+      def progress_hash
+        qs = survey.sections_with_questions.map(&:questions).flatten
+        ds = dependencies(qs.map(&:id))
+        triggered = qs - ds.select{|d| !d.is_met?(self)}.map(&:question)
+        { :questions => qs.compact.size,
+          :triggered => triggered.compact.size,
+          :triggered_mandatory => triggered.select{|q| q.mandatory?}.compact.size,
+          :triggered_mandatory_completed => triggered.select{|q| q.mandatory? and is_answered?(q)}.compact.size
+        }
+      end
+      def is_answered?(question)
+        %w(label image).include?(question.display_type) or !is_unanswered?(question)
+      end
+      def is_unanswered?(question)
+        self.responses.detect{|r| r.question_id == question.id}.nil?
+      end
+
+      # Returns the number of response groups (count of group responses enterted) for this question group
+      def count_group_responses(questions)
+        questions.map{|q| responses.select{|r| (r.question_id.to_i == q.id.to_i) && !r.response_group.nil?}.group_by(&:response_group).size }.max
+      end
+
+      def unanswered_dependencies
+        dependencies.select{|d| d.is_met?(self) and self.is_unanswered?(d.question)}.map(&:question)
+      end
+
+      def all_dependencies
+        arr = dependencies.partition{|d| d.is_met?(self) }
+        {:show => arr[0].map{|d| d.question_group_id.nil? ? "question_#{d.question_id}" : "question_group_#{d.question_group_id}"}, :hide => arr[1].map{|d| d.question_group_id.nil? ? "question_#{d.question_id}" : "question_group_#{d.question_group_id}"}}
+      end
+
+      # Check existence of responses to questions from a given survey_section
+      def no_responses_for_section?(section)
+        self.responses.count(:conditions => {:survey_section_id => section.id}) == 0
+      end
+
+      protected
+
+      def dependencies(question_ids = nil)
+        question_ids ||= Question.find_all_by_survey_section_id(current_section_id).map(&:id)
+        depdendecy_ids = DependencyCondition.all(:conditions => {:question_id => question_ids}).map(&:dependency_id)
+        Dependency.find(depdendecy_ids, :include => :dependency_conditions)
+      end
+    end
+  end
+end

data/lib/surveyor/models/survey_methods.rb

@@ -0,0 +1,63 @@
+module Surveyor
+  module Models
+    module SurveyMethods
+      def self.included(base)
+        # Associations
+        base.send :has_many, :sections, :class_name => "SurveySection", :order => 'display_order'
+        base.send :has_many, :sections_with_questions, :include => :questions, :class_name => "SurveySection", :order => 'display_order'
+        base.send :has_many, :response_sets
+
+        # Scopes
+        base.send :named_scope, :with_sections, {:include => :sections}
+
+        # Validations
+        base.send :validates_presence_of, :title
+        base.send :validates_uniqueness_of, :access_code
+
+        # 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.inactive_at ||= DateTime.now
+      end
+
+      def title=(value)
+        self.access_code = Surveyor::Common.to_normalized_string(value)
+        super
+      end
+
+      def active?
+        self.active_as_of?(DateTime.now)
+      end
+      def active_as_of?(datetime)
+        (self.active_at.nil? or self.active_at < datetime) and (self.inactive_at.nil? or self.inactive_at > datetime)
+      end  
+      def activate!
+        self.active_at = DateTime.now
+      end
+      def deactivate!
+        self.inactive_at = DateTime.now
+      end
+      def active_at=(datetime)
+        self.inactive_at = nil if !datetime.nil? and !self.inactive_at.nil? and self.inactive_at < datetime
+        super(datetime)
+      end
+      def inactive_at=(datetime)
+        self.active_at = nil if !datetime.nil? and !self.active_at.nil? and self.active_at > datetime
+        super(datetime)
+      end
+    end
+  end
+end

data/lib/surveyor/models/survey_section_methods.rb

@@ -0,0 +1,21 @@
+module Surveyor
+  module Models
+    module SurveySectionMethods
+      def self.included(base)
+        # Associations
+        base.send :has_many, :questions, :order => "display_order ASC", :dependent => :destroy
+        base.send :belongs_to, :survey
+
+        # Scopes
+        base.send :default_scope, :order => "display_order ASC"
+        base.send :named_scope, :with_includes, { :include => {:questions => [:answers, :question_group, {:dependency => :dependency_conditions}]}}
+
+        # Validations
+        base.send :validates_presence_of, :title, :survey, :display_order
+      end
+
+      # Instance Methods
+
+    end
+  end
+end

data/lib/surveyor/models/validation_condition_methods.rb

@@ -0,0 +1,48 @@
+module Surveyor
+  module Models
+    module ValidationConditionMethods
+      def self.included(base)
+        # Associations
+        base.send :belongs_to, :validation
+
+        # Scopes
+
+        # Validations
+        base.send :validates_numericality_of, :validation_id #, :question_id, :answer_id
+        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
+
+        base.send :acts_as_response # 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
+          !(response.as(klass).to_s =~ Regexp.new(self.regexp || "")).nil?
+        else
+          false
+        end
+      end
+    end
+  end
+end

data/lib/surveyor/models/validation_methods.rb

@@ -0,0 +1,40 @@
+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
+        base.send :validates_presence_of, :rule
+        base.send :validates_format_of, :rule, :with => /^(?:and|or|\)|\(|[A-Z]|\s)+$/
+        base.send :validates_numericality_of, :answer_id
+
+      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.rb

@@ -1,6 +1,6 @@
 require 'surveyor/common'
 require 'surveyor/acts_as_response'
 
-
-Dir.glob(File.join(File.dirname(__FILE__),'..','app','models','*.rb')).each{|f| require f}
-Dir.glob(File.join(File.dirname(__FILE__),'..','app','helpers','*.rb')).each{|f| require f}
+# 
+# Dir.glob(File.join(File.dirname(__FILE__),'..','app','models','*.rb')).each{|f| require f}
+# Dir.glob(File.join(File.dirname(__FILE__),'..','app','helpers','*.rb')).each{|f| require f}

data/rails/init.rb

@@ -1 +1 @@
-# Init hook code here
+require 'surveyor'

data/surveyor.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{surveyor}
-  s.version = "0.14.4"
+  s.version = "0.14.5"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Brian Chamberlain", "Mark Yoon"]
-  s.date = %q{2010-08-31}
+  s.date = %q{2010-09-01}
   s.email = %q{yoon@northwestern.edu}
   s.extra_rdoc_files = [
     "README.md"
@@ -56,11 +56,8 @@ Gem::Specification.new do |s|
      "features/surveyor.feature",
      "generators/extend_surveyor/extend_surveyor_generator.rb",
      "generators/extend_surveyor/templates/EXTENDING_SURVEYOR",
-     "generators/extend_surveyor/templates/extensions/survey_extensions.rb",
      "generators/extend_surveyor/templates/extensions/surveyor_controller.rb",
-     "generators/extend_surveyor/templates/extensions/surveyor_controller_extensions.rb",
      "generators/extend_surveyor/templates/extensions/surveyor_custom.html.erb",
-     "generators/extend_surveyor/templates/extensions/surveyor_helper_extensions.rb",
      "generators/surveyor/surveyor_generator.rb",
      "generators/surveyor/templates/README",
      "generators/surveyor/templates/assets/images/222222_11x11_icon_arrows_leftright.gif",
@@ -145,6 +142,17 @@ Gem::Specification.new do |s|
      "lib/surveyor.rb",
      "lib/surveyor/acts_as_response.rb",
      "lib/surveyor/common.rb",
+     "lib/surveyor/models/answer_methods.rb",
+     "lib/surveyor/models/dependency_condition_methods.rb",
+     "lib/surveyor/models/dependency_methods.rb",
+     "lib/surveyor/models/question_group_methods.rb",
+     "lib/surveyor/models/question_methods.rb",
+     "lib/surveyor/models/response_methods.rb",
+     "lib/surveyor/models/response_set_methods.rb",
+     "lib/surveyor/models/survey_methods.rb",
+     "lib/surveyor/models/survey_section_methods.rb",
+     "lib/surveyor/models/validation_condition_methods.rb",
+     "lib/surveyor/models/validation_methods.rb",
      "lib/surveyor/surveyor_controller_methods.rb",
      "lib/tasks/surveyor_tasks.rake",
      "rails/init.rb",