surveyor 0.14.5 → 0.15.0

data/lib/surveyor/models/validation_condition_methods.rb

@@ -8,12 +8,13 @@ module Surveyor
         # 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
+        # this causes issues with building and saving
+        # base.send :validates_numericality_of, :validation_id #, :question_id, :answer_id
 
-        base.send :acts_as_response # includes "as" instance method
+        base.send :include, Surveyor::ActsAsResponse # includes "as" instance method
 
         # Class methods
         base.instance_eval do

data/lib/surveyor/models/validation_methods.rb

@@ -11,8 +11,8 @@ module Surveyor
         # 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
-
+        # this causes issues with building and saving
+        # base.send :validates_numericality_of, :answer_id
       end
 
       # Instance Methods

data/lib/surveyor/parser.rb

@@ -0,0 +1,274 @@
+module Surveyor
+  class Parser
+    # Attributes
+    attr_accessor :context
+
+    # Class methods
+    def self.parse(str)
+      puts
+      Surveyor::Parser.new.instance_eval(str)
+      puts
+    end
+
+    # Instance methods
+    def initialize
+      self.context = {}
+    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)
+      
+      print 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?
+      
+      # parse and build
+      type.classify.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'
+          puts
+          print context[type.to_sym].save ? "saved. " : " not saved! #{context[type.to_sym].errors.each_full{|x| x }.join(", ")} "
+        end
+        context[type.to_sym].clear(context)
+      end
+    end
+    
+    # Private methods
+    private
+
+    def full(method_name)
+      case method_name.to_s
+      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
+  end
+end
+
+# Surveyor models with extra parsing methods
+class Survey < ActiveRecord::Base
+  # block
+  include Surveyor::Models::SurveyMethods
+  
+  def self.parse_and_build(context, args, original_method, reference_identifier)
+    # clear context
+    context.delete_if{|k,v| true}
+    context[:question_references] = {}
+    context[:answer_references] = {}
+    
+    # build and set context
+    title = args[0]
+    context[:survey] = new({  :title => title, 
+                              :reference_identifier => reference_identifier}.merge(args[1] || {}))
+  end
+  def clear(context)
+    context.delete_if{|k,v| true}
+    context[:question_references] = {}
+    context[:answer_references] = {}
+  end
+end
+class SurveySection < ActiveRecord::Base
+  # block
+  include Surveyor::Models::SurveySectionMethods
+  
+  def self.parse_and_build(context, args, original_method, reference_identifier)
+    # clear context
+    context.delete_if{|k,v| k != :survey && k != :question_references && k != :answer_references}
+    
+    # build and set context
+    title = args[0]
+    context[:survey_section] = context[:survey].sections.build({ :title => title, 
+                                                                :data_export_identifier => Surveyor::Common.normalize(title)}.merge(args[1] || {}))
+  end
+  def clear(context)
+    context.delete_if{|k,v| k != :survey && k != :question_references && k != :answer_references}
+  end
+end
+class QuestionGroup < ActiveRecord::Base
+  # block
+  include Surveyor::Models::QuestionGroupMethods
+  
+  def self.parse_and_build(context, args, original_method, reference_identifier)
+    # clear context
+    context.delete_if{|k,v| k != :survey && k != :survey_section && k != :question_references && k != :answer_references}
+    
+    # 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] || {}))
+
+  end
+  def clear(context)
+    context.delete_if{|k,v| k != :survey && k != :survey_section && k != :question_references && k != :answer_references}
+  end
+end
+class Question < ActiveRecord::Base
+  # nonblock
+  include Surveyor::Models::QuestionMethods
+  
+  def self.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}
+    
+    # build and set context
+    text = args[0] || "Question"
+    context[:question] = context[:survey_section].questions.build({
+      :question_group => context[:question_group],
+      :reference_identifier => reference_identifier,
+      :text => text,
+      :short_text => text, 
+      :display_type => (original_method =~ /label|image/ ? original_method : "default"),
+      :data_export_identifier => Surveyor::Common.normalize(text)}.merge(args[1] || {}))
+    
+    # keep reference for dependencies
+    context[:question_references][reference_identifier] = context[:question] unless reference_identifier.blank?
+    
+    # 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][grid_answer.reference_identifier] = a unless reference_identifier.blank? or grid_answer.reference_identifier.blank?
+      end
+    end
+  end
+end
+class Dependency < ActiveRecord::Base
+  # nonblock
+  include Surveyor::Models::DependencyMethods
+  
+  def self.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}
+    
+    # build and set context
+    context[:dependency] = context[:question].build_dependency({ :question_group => context[:question_group]}.merge(args[0] || {}))
+  end
+end
+class DependencyCondition < ActiveRecord::Base
+  # nonblock
+  include Surveyor::Models::DependencyConditionMethods
+  
+  attr_accessor :question_reference, :answer_reference, :context_reference
+  before_save :resolve_references
+  
+  def self.parse_and_build(context, args, original_method, reference_identifier)
+    # clear context
+    context.delete_if{|k,v| k == :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
+      print (self.question = context_reference[:question_references][question_reference]) ? "found question:#{question_reference} " : "lost! question:#{question_reference} "
+      context_reference[:answer_references][question_reference] ||= {}
+      print (self.answer = context_reference[:answer_references][question_reference][answer_reference]) ? "found answer:#{answer_reference} " : "lost! answer:#{answer_reference} "
+    end
+  end
+  
+end
+class Answer < ActiveRecord::Base
+  # nonblock
+  include Surveyor::Models::AnswerMethods
+  
+  def self.parse_and_build(context, args, original_method, reference_identifier)
+    # clear context
+    context.delete_if{|k,v| %w(answer validation validation_condition).map(&:to_sym).include? k}
+
+    attrs = { :reference_identifier => reference_identifier,
+              :is_exclusive => false,
+              :hide_label => false,
+              :response_class => "answer"}.merge(self.parse_args(args))
+                              
+    # add answers to grid
+    if context[:question_group] && context[:question_group].display_type == "grid"
+      context[:answer] = new(attrs)
+      context[:grid_answers] ||= []
+      context[:grid_answers] << context[:answer]
+    else
+      context[:answer] = context[:question].answers.build(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?
+    end
+  end
+  def self.parse_args(args)
+    case args[0]
+    when Hash # Hash
+      self.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] || {})
+    when Symbol # (Symbol, Hash) or (Symbol, Symbol, Hash)
+      self.symbol_args(args[0]).merge(self.hash_from args[1]).merge(args[2] || {})
+    else
+      self.text_args(nil)
+    end
+  end
+  def self.text_args(text = "Answer")
+    {:text => text.to_s, :short_text => text, :data_export_identifier => Surveyor::Common.normalize(text)}
+  end
+  def self.hash_from(arg)
+    arg.is_a?(Symbol) ? {:response_class => arg.to_s} : arg.is_a?(Hash) ? arg : {}
+  end
+  def self.symbol_args(arg)
+    case arg
+    when :other
+      self.text_args("Other")
+    when :other_and_string
+      self.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})
+    when :integer, :date, :time, :datetime, :text, :datetime, :string
+      self.text_args(arg.to_s.humanize).merge({:response_class => arg.to_s, :hide_label => true})
+    end
+  end
+end
+class Validation < ActiveRecord::Base
+  # nonblock
+  include Surveyor::Models::ValidationMethods
+  
+  def self.parse_and_build(context, args, original_method, reference_identifier)
+    # clear context
+    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] || {}))
+  end
+end
+class ValidationCondition < ActiveRecord::Base
+  # nonblock
+  include Surveyor::Models::ValidationConditionMethods
+  
+  def self.parse_and_build(context, args, original_method, reference_identifier)
+    # clear context
+    context.delete_if{|k,v| k == :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 || {}))
+  end
+end

data/lib/tasks/surveyor_tasks.rake

@@ -1,35 +1,35 @@
 desc "generate and load survey (specify FILE=surveys/your_survey.rb)"
-task :surveyor => :"surveyor:default"
+task :surveyor => :"surveyor:parse"
 
 namespace :surveyor do
-  
-  task :default => [:generate_fixtures, :load_fixtures]
-  
-  desc "generate survey fixtures from survey file"
-  task :generate_fixtures => :environment do
-    require File.join(File.dirname(__FILE__), "../../script/surveyor/parser")
+  task :parse => :environment do
     raise "USAGE: file name required e.g. 'FILE=surveys/kitchen_sink_survey.rb'" if ENV["FILE"].blank?
-    fixture_dir = File.join(RAILS_ROOT, "surveys", "fixtures")
-    mkdir fixture_dir unless File.exists?(fixture_dir)
-    SurveyParser::Parser.parse(File.join(RAILS_ROOT, ENV["FILE"]))
+    file = File.join(RAILS_ROOT, ENV["FILE"])
+    raise "File does not exist: #{file}" unless FileTest.exists?(file)
+    puts "--- Parsing #{file} ---"
+    Surveyor::Parser.parse File.read(file)
+    puts "--- Done #{file} ---"
   end
-
-  desc "load survey fixtures"
-  task :load_fixtures => :environment do
-    require 'active_record/fixtures'
-    require 'fixtures_extensions' unless ENV["APPEND"].blank?
-    ActiveRecord::Base.establish_connection(Rails.env)
-
-    fixture_dir = File.join(RAILS_ROOT, "surveys", "fixtures")
-    fixtures = Dir.glob("#{fixture_dir}/*.yml")
-    raise "No fixtures found." if fixtures.empty?
-    
-    fixtures.each do |file_name|
-      puts "Loading #{file_name}..."
-      Fixtures.create_fixtures(fixture_dir, File.basename(file_name, '.*'))
+  desc "remove surveys (that don't have response sets)"
+  task :remove => :environment do
+    surveys = Survey.all.delete_if{|s| !s.response_sets.blank?}
+    if surveys
+      puts "The following surveys do not have any response sets"
+      surveys.each do |survey|
+        puts "#{survey.id} #{survey.title}"
+      end
+      puts "Which survey would you like to remove?"
+      id = $stdin.gets.to_i
+      if survey_to_delete = surveys.detect{|s| s.id == id}
+        puts "removing #{survey_to_delete.title}"
+        survey_to_delete.destroy
+      else
+        put "not found"
+      end
+    else
+      puts "There are no surveys surveys without response sets"      
     end
   end
-
 end
 
 namespace :spec do

data/spec/factories.rb

@@ -103,7 +103,7 @@ end
 Factory.define :response_set do |r|
   r.user_id         {}
   r.association     :survey # r.survey_id       {}
-  r.access_code     {Surveyor.make_tiny_code}
+  r.access_code     {Surveyor::Common.make_tiny_code}
   r.started_at      {Time.now}
   r.completed_at    {}
 end

data/spec/lib/common_spec.rb

@@ -0,0 +1,22 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe Surveyor::Common, "" do
+  it "should convert text to a code that is more appropirate for a database entry" do
+    # A few answers from the survey
+    { "This? is a in - t3rrible-@nswer of! (question) on" => "this_t3rrible_nswer",
+      "Private insurance/ HMO/ PPO" => "private_insurance_hmo_ppo",
+      "<bold>VA</bold>" => "va",
+      "PMS (Premenstrual syndrome)/ PMDD (Premenstrual Dysphoric Disorder)" => "pms_pmdd",
+      "Have never been employed outside the home" => "never_been_employed_outside_home",
+      "Professional" => "professional",
+      "Not working because of temporary disability, but expect to return to a job" => "temporary_disability_expect_return_job",
+      "How long has it been since you last visited a doctor for a routine checkup (routine being not for a particular reason)?" => "visited_doctor_for_routine_checkup",
+      "Do you take medications as directed?" => "you_take_medications_as_directed",
+      "Do you every leak urine (or) water when you didn't want to?" => "urine_water_you_didnt_want", #checking for () and ' removal
+      "Do your biological family members (not adopted) have a \"history\" of any of the following?" => "family_members_history_any_following",
+      "Your health:" => "your_health",
+      "In general, you would say your health is:" => "you_would_say_your_health"
+    }.each{|k, v| Surveyor::Common.to_normalized_string(k).should == v}
+  end
+  
+end

data/spec/lib/parser_spec.rb

@@ -0,0 +1,30 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe Surveyor::Parser do
+  before(:each) do
+    @parser = Surveyor::Parser.new
+  end
+  it "should translate shortcuts into full model names" do
+    @parser.send(:full, "section").should == "survey_section"
+    @parser.send(:full, "g").should == "question_group"
+    @parser.send(:full, "repeater").should == "question_group"
+    @parser.send(:full, "label").should == "question"
+    @parser.send(:full, "vc").should == "validation_condition"
+    @parser.send(:full, "vcondition").should == "validation_condition"
+  end
+  it "should translate 'condition' based on context" do
+    @parser.send(:full, "condition").should == "dependency_condition"
+    @parser.send(:full, "c").should == "dependency_condition"
+    @parser.context[:validation] = Validation.new
+    @parser.send(:full, "condition").should == "validation_condition"
+    @parser.send(:full, "c").should == "validation_condition"
+    @parser.context[:validation] = nil
+    @parser.send(:full, "condition").should == "dependency_condition"
+    @parser.send(:full, "c").should == "dependency_condition"
+  end
+  it "should identify models that take blocks" do
+    @parser.send(:block_models).should == %w(survey survey_section question_group)
+  end
+  
+  
+end

data/spec/models/answer_spec.rb

@@ -8,11 +8,12 @@ describe Answer, "when creating a new answer" do
   it "should be valid" do
     @answer.should be_valid
   end
-
-  it "should be invalid without a question_id" do
-    @answer.question_id = nil
-    @answer.should_not be_valid
-  end
+  
+  # this causes issues with building and saving answers to questions within a grid.
+  # it "should be invalid without a question_id" do
+  #   @answer.question_id = nil
+  #   @answer.should_not be_valid
+  # end
   
   it "should have 'default' renderer with nil question.pick and response_class" do      
     @answer.question = Factory(:question, :pick => nil)