breakpointer-surveyor 0.2.0

data/app/helpers/surveys_helper.rb

@@ -0,0 +1,2 @@
+module SurveysHelper
+end

data/app/models/answer.rb

@@ -0,0 +1,18 @@
+class Answer < ActiveRecord::Base
+
+  # Associations
+  belongs_to :question
+  has_many :responses
+  
+  # Validations
+  validates_presence_of :text
+  validates_numericality_of :question_id, :allow_nil => false, :only_integer => true
+  #validates_uniqueness_of :reference_identifier
+  
+  # Methods
+  def partial_name
+    [(self.question.pick == "none")? nil : self.question.pick.downcase, self.response_class.downcase].compact.join("_")
+  end
+
+  
+end

data/app/models/dependency.rb

@@ -0,0 +1,43 @@
+class Dependency < ActiveRecord::Base
+  # Associations
+  belongs_to :question
+  has_many :dependency_conditions
+
+  # Validations
+  validates_presence_of :rule
+  validates_format_of :rule, :with => /^(?:and|or|\)|\(|\d|\s)+$/ #TODO properly formed parenthesis etc.
+  validates_numericality_of :question_id
+
+  # Attribute aliases
+  alias_attribute :dependent_question_id, :question_id
+
+  # Is the method that determines if this dependency has been met within
+  # the provided response set
+  def met?(response_set)
+    if keyed_pairs = keyed_conditions(response_set)
+      return(rule_evaluation(keyed_pairs))
+    else
+      return(false)
+    end
+  end
+
+  # Pairs up the substitution key with the evaluated condition result for substitution into the rule
+  # Example: If you have two dependency conditions with rule keys "A" and "B" in the rule "A or B"
+  # calling keyed_condition_pairs will return {:A => true, :B => false}
+  def keyed_conditions(response_set)
+    keyed_pairs = {}
+    self.dependency_conditions.each do |dc|
+      keyed_pairs.merge!(dc.to_evaluation_hash(response_set))
+    end
+    return(keyed_pairs)
+  end
+
+  # Does the substiution and evaluation of the dependency rule with the keyed pairs
+  def rule_evaluation(keyed_pairs)
+    # subtitute into rule for evaluation
+    rgx = Regexp.new(self.dependency_conditions.map{|dc| dc.rule_key}.join("|")) # Making a regexp to only look for the keys used in the child conditions
+    #logger.debug("rexp: #{rgx.inspect} FOO: #{keyed_pairs.inspect} --- subbed rules: #{rule.gsub(rgx){|m| keyed_pairs[m.to_sym]}} --> #{eval(self.rule.gsub(rgx){|m| keyed_pairs[m.to_sym]})}")
+    eval(self.rule.gsub(rgx){|m| keyed_pairs[m.to_sym]}) # returns the evaluation of the rule and the conditions
+  end
+  
+end

data/app/models/dependency_condition.rb

@@ -0,0 +1,76 @@
+class DependencyCondition < ActiveRecord::Base
+  # Constants
+  OPERATORS = %w(== != < > <= >=) # CONSTANT or @@class_variable when validations listed before class method
+
+  # Associations
+  belongs_to :answer
+  belongs_to :dependency
+  belongs_to :dependent_question, :foreign_key => :question_id, :class_name => :question
+
+  # Validations
+  validates_numericality_of :dependency_id, :question_id, :answer_id
+  validates_presence_of :operator, :rule_key
+  validates_inclusion_of :operator, :in => OPERATORS
+  validates_uniqueness_of :rule_key, :scope => :dependency_id
+
+  # Class methods
+  def self.operators
+    OPERATORS
+  end
+
+  # Evaluates the condition on the response_set
+  def evaluation_of(response_set)
+    response = response_set.find_response(self.answer_id) || false # turns out eval("nil and false") => nil so we need to return false if no response is found
+    return(response and self.is_satisfied_by?(response))
+  end
+
+  # Checks to see if the response passed in satisfies the dependency condition
+  def is_satisfied_by?(response)
+    response_class = response.answer.response_class 
+    return case self.operator
+    when "=="
+      response.as(response_class) == self.as(response_class)
+    when "!="
+      response.as(response_class) != self.as(response_class)
+    when "<"
+      response.as(response_class) < self.as(response_class)
+    when ">"
+      response.as(response_class) > self.as(response_class)
+    when "<="
+      response.as(response_class) <= self.as(response_class)
+    when ">="
+      response.as(response_class) >= self.as(response_class)
+    else
+      false
+    end
+  end
+
+  # Method that returns the dependency as a particular response_class type
+  def as(type_symbol)
+    return case type_symbol.to_sym
+    when :string
+      self.string_value
+    when :text
+      self.text_value
+    when :integer
+      self.integer_value
+    when :float
+      self.float_value
+    when :answer
+      self.answer_id
+    else
+      self.answer_id
+    end
+  end
+  
+  # The hash used in the dependency parent object to evaluate its rule string
+  def to_evaluation_hash(response_set)
+    {self.symbol_key => self.evaluation_of(response_set)}
+  end
+  
+  # Returns the rule key to be used in the subsitution string in the parent depenedency object
+  def symbol_key
+    self.rule_key.to_sym
+  end
+
+end

data/app/models/question.rb

@@ -0,0 +1,44 @@
+class Question < ActiveRecord::Base
+  
+  # Associations
+  belongs_to :survey_section
+  belongs_to :question_group
+  has_many :answers # it might not always have answers
+  has_one :dependency
+  
+  # Validations
+  validates_presence_of :text, :survey_section_id, :display_order
+  validates_inclusion_of :is_mandatory, :in => [true, false]
+  
+  # Instance Methods
+  def initialize(*args)
+    super(*args)
+    default_args
+  end
+  
+  def default_args
+    # self.is_active ||= false
+    self.is_mandatory ||= true
+  end
+  
+  def mandatory?
+    self.is_mandatory == true
+  end
+  
+  def display_type
+    super || "default"
+  end
+  
+  def has_dependency?
+    self.dependency != nil
+  end
+  
+  def dependency_satisfied?(response_set)
+    self.has_dependency? and self.dependency.met?(response_set)
+  end
+  
+  def part_of_group?
+    !self.question_group.nil?
+  end
+  
+end

data/app/models/question_group.rb

@@ -0,0 +1,5 @@
+class QuestionGroup < ActiveRecord::Base
+  
+  has_many :questions
+  
+end

data/app/models/response.rb

@@ -0,0 +1,58 @@
+class Response < ActiveRecord::Base
+  include ActionView::Helpers::SanitizeHelper
+         
+  # Associations
+  belongs_to :response_set
+  belongs_to :question
+  belongs_to :answer
+  
+  # Validations
+  validates_presence_of :response_set_id, :question_id, :answer_id
+  
+  # Named scopes
+  named_scope :in_section, lambda {|section_id| {:include => :question, :conditions => ['questions.survey_section_id =?', section_id.to_i ]}}
+
+  def selected
+    !self.new_record?
+  end
+  
+  alias_method :selected?, :selected
+  
+  def selected=(value)
+    true
+  end
+
+  #Method that returns the response as a particular response_class type
+  def as(type_symbol)
+    return case type_symbol.to_sym
+    when :string
+      self.string_value
+    when :text
+      self.text_value
+    when :integer
+      self.integer_value
+    when :float
+      self.float_value
+    when :date
+      self.datetime_value.nil? ? nil : self.datetime_value.to_date
+    when :time
+      self.datetime_value.nil? ? nil : self.datetime_value.to_time
+    when :datetime
+      self.datetime_value
+    when :answer
+      self.answer_id
+    else
+      self.answer_id
+    end
+  end
+  
+  def to_s
+    if self.answer_id
+      self.answer.text
+    else
+      "#{(self.string_value || self.text_value || self.integer_value || self.float_value).to_s}"
+    end
+    
+  end
+  
+end

data/app/models/response_set.rb

@@ -0,0 +1,174 @@
+class ResponseSet < ActiveRecord::Base
+  include TinyCode
+  
+  # Associations
+  belongs_to :survey
+  belongs_to :user
+  has_many :responses, :dependent => :destroy
+  
+  # Validations
+  validates_presence_of :survey_id, :user_id
+  validates_associated :responses
+  
+  # Attributes
+  attr_protected :completed_at
+  attr_accessor :current_section_id
+
+  # Callbacks
+  after_update :save_responses
+  
+  # Instance methods
+  def initialize(*args)
+    super(*args)
+    default_args
+  end
+  
+  def default_args
+    self.started_at ||= Time.now
+    self.access_code = ResponseSet.make_tiny_code
+  end
+  
+  def response_for(question_id, answer_id, response_group = nil)
+    found = responses.find_by_question_id_and_answer_id_and_response_group(question_id, answer_id, response_group)
+    found.blank? ? responses.new(:question_id => question_id, :answer_id => answer_id, :response_group => response_group) : found
+  end
+  
+  # "responses"=>{
+  #string   "6"=>{"question_id"=>"6", "20"=>{"string_value"=>"saf"}}, 
+  #text   "7"=>{"question_id"=>"7", "21"=>{"text_value"=>""}}, 
+  #radio+txt   "1"=>{"question_id"=>"1", "answer_id"=>"1", "4"=>{"string_value"=>""}}, 
+  #radio   "2"=>{"answer_id"=>"6"}, 
+  #radio   "3"=>{"answer_id"=>"10"}, 
+  #check   "4"=>{"question_id"=>"4", "answer_id"=>"15"}, 
+  #check+txt   "5"=>{"question_id"=>"5", "16"=>{"selected"=>"1"}, "19"=>{"string_value"=>""}}
+  #   },
+  # "survey_code"=>"test_survey", 
+  # "commit"=>"Next Section (Utensiles and you!) >>", 
+  # "authenticity_token"=>"8bee21081eea820ab1c658358c0baaa2e46de5d1", 
+  # "_method"=>"put", 
+  # "action"=>"update", 
+  # "controller"=>"app", 
+  # "response_set_code"=>"T2x8HhCQej", 
+  # "section"=>"2"
+
+  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}.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}.merge(response_hash))
+          end
+        end
+      end
+    end
+  end
+  
+  # "24"=>{
+  #   "0"=>{"response_group"=>"0", "question_id"=>"24", "answer_id"=>"172"}, "1"=>{"response_group"=>"1", "question_id"=>"24", "answer_id"=>"173"}, 
+  #   "2"=>{"response_group"=>"2", "question_id"=>"24", "answer_id"=>""}, "3"=>{"response_group"=>"3", "question_id"=>"24", "answer_id"=>""}, 
+  #   "4"=>{"response_group"=>"4", "question_id"=>"24", "answer_id"=>""}},
+ #  where "24" is the question id
+ 
+ # Some other examples:
+ # "25"=>{
+ # "0"=>{"response_group"=>"0", "question_id"=>"25", "179"=>{"string_value"=>"camry"}}, 
+ # "1"=>{"response_group"=>"1", "question_id"=>"25", "179"=>{"string_value"=>"f150"}},
+ #  "2"=>{"response_group"=>"2", "question_id"=>"25", "179"=>{"string_value"=>""}}, 
+ #  "3"=>{"response_group"=>"3", "question_id"=>"25", "179"=>{"string_value"=>""}}, 
+ #  "4"=>{"response_group"=>"4", "question_id"=>"25", "179"=>{"string_value"=>""}}}, 
+ # 
+ # "26"=>{
+ # "0"=>{"response_group"=>"0", "question_id"=>"26", "180"=>{"string_value"=>"1999"}},
+ #  "1"=>{"response_group"=>"1", "question_id"=>"26", "180"=>{"string_value"=>"2004"}}, 
+ #  "2"=>{"response_group"=>"2", "question_id"=>"26", "180"=>{"string_value"=>""}}, 
+ #  "3"=>{"response_group"=>"3", "question_id"=>"26", "180"=>{"string_value"=>""}}, 
+ #  "4"=>{"response_group"=>"4", "question_id"=>"26", "180"=>{"string_value"=>""}}}, 
+ # 
+ # "27"=>{
+ # "0"=>{"182"=>{"integer_value"=>""}, "response_group"=>"0", "question_id"=>"27", "181"=>{"string_value"=>""}}, 
+ # "1"=>{"182"=>{"integer_value"=>""}, "response_group"=>"1", "question_id"=>"27", "181"=>{"string_value"=>""}},
+ #  "2"=>{"182"=>{"integer_value"=>""}, "response_group"=>"2", "question_id"=>"27", "181"=>{"string_value"=>""}}, 
+ #  "3"=>{"182"=>{"integer_value"=>""}, "response_group"=>"3", "question_id"=>"27", "181"=>{"string_value"=>""}}, 
+ #  "4"=>{"182"=>{"integer_value"=>""}, "response_group"=>"4", "question_id"=>"27", "181"=>{"string_value"=>""}}}},
+ 
+ # 0,1,2,3,4 are the response group numbers
+ # and anything else in the response group hash is handled normally 
+  
+  # method to process responses in response groups
+  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}.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}.merge(inner_hash))
+            end
+          end
+        end
+        
+      end
+    end
+  end
+  
+  
+  def save_responses
+    responses.each do |response|
+      response.save(false)
+    end
+  end
+
+  # ResponseSet has an awareness of its internal state
+  def empty?
+    self.responses.empty?
+  end
+
+  def complete!
+    self.completed_at = Time.now
+  end
+  
+  def has_answered_question?(question)
+   !has_not_answered_question?(question)
+  end
+  
+  def has_not_answered_question?(question)
+    self.responses.find_all_by_question_id(question.id).empty?
+  end
+  
+  # ResponseSet knows if certain answers are contained in this response set
+  # This method acts as an interface for the dependency analysis
+  def find_response(answer_id)
+     self.responses.find_by_answer_id(answer_id)
+  end
+  
+  # Counts the number of responses for the current user for this question
+  def count_question_responses(question)
+    Response.count(:conditions => ["response_set_id =? AND question_id=?", self.id, question.id])
+  end
+  
+  # Returns the number of response groups (count of group responses enterted) for this question group
+  def count_group_responses(group)
+    counts = []
+    group.questions.each do |question|
+      counts << Response.count("response_group",:conditions => ["response_set_id =? AND question_id=? AND response_group IS NOT NULL", self.id, question.id], :distinct => true)
+    end
+    
+    counts.max #since response groups can be partially filled, such that for one response group the user may have answered only one of the questions in the group. We want to still count the partially complete group response.
+  end
+  
+end

data/app/models/survey.rb

@@ -0,0 +1,54 @@
+class Survey < ActiveRecord::Base
+  include TinyCode
+  
+  # Associations
+  has_many :sections, :class_name => "SurveySection", :order => 'display_order'
+  has_many :sections_with_questions, :include => :questions, :class_name => "SurveySection", :order => 'display_order'
+  has_many :response_sets
+  
+  # Validations
+  validates_presence_of :title
+  
+  # Class methods
+  def self.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
+  
+  # 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 = Survey.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