surveyor 0.8.0 → 0.9.0

data/script/surveyor/base.rb

@@ -0,0 +1,61 @@
+class SurveyParser
+  class Base
+    
+    # Class level instance variable, because class variable are shared with subclasses
+    class << self
+      attr_accessor :children
+    end
+    
+    @children = []
+    
+    # Class methods
+    def self.inherited(subclass)
+      # set the class level instance variable default on subclasses
+      subclass.instance_variable_set(:@children, self.instance_variable_get(:@children))
+    end
+    
+    def self.has_children(*args)
+      args.each{|model| attr_accessor model}
+      self.instance_variable_set(:@children, args)
+    end
+    
+    # Instance methods
+    def initialize(obj, args, opts)
+      # inherit the parser from parent (obj)
+      self.parser = (obj.nil? ? nil : obj.class == SurveyParser ? obj : obj.parser)
+      # get a new id from the parser
+      self.id = parser.nil? ? nil : parser.send("new_#{self.class.name.underscore}_id")
+      # set [parent]_id to obj.id, if we have that attribute
+      self.send("#{obj.class.name.underscore}_id=", obj.nil? ? nil : obj.id) if self.respond_to?("#{obj.class.name.underscore}_id=") 
+      # initialize descendant models
+      self.class.children.each{|model| self.send("#{model}=", [])}
+      # combine default options, parsed opts, parsed args, and initialize instance variables
+      self.default_options.merge(parse_opts(opts)).merge(parse_args(args)).each{|k,v| self.send("#{k.to_s}=", v)}
+      # print to the log
+      print "#{self.class.name.gsub(/[a-z]/, "")[-1,1]}#{self.id} "
+    end
+    def default_options
+      {}
+    end
+    def parse_opts(opts)
+      opts.reject{|k,v| k == :method_name} # toss the method name by default
+    end
+    def parse_args(args)
+      args[0] || {}
+    end
+    
+    # Filter out attributes that shouldn't be in fixtures, including children, parser, placeholders
+    def yml_attrs
+      instance_variables.sort - self.class.children.map{|model| "@#{model.to_s}"} - %w(@parser @dependency @validation @question_reference @answer_reference)
+    end
+    def to_yml
+      out = [ %(#{@data_export_identifier}_#{@id}:) ]
+      yml_attrs.each{|a| out << "  #{a[1..-1]}: #{instance_variable_get(a).is_a?(String) ? "\"#{instance_variable_get(a)}\"" : instance_variable_get(a) }"}
+      (out << nil ).join("\r\n")
+    end
+    def to_file
+      File.open(self.parser.send("#{self.class.name.underscore.pluralize}_yml"), File::CREAT|File::APPEND|File::WRONLY) {|f| f << to_yml}
+      self.class.children.each{|model| self.send(model).compact.map(&:to_file)}
+    end
+  end
+end

data/script/surveyor/dependency.rb

@@ -1,48 +1,11 @@
-class Dependency
-  
+class Dependency < SurveyParser::Base
   # Context, Conditional, Children
   attr_accessor :id, :question_id, :question_group_id, :parser
   attr_accessor :rule
-  attr_accessor :dependency_conditions
+  has_children :dependency_conditions
 
-  # id, question, and rule required
-  def initialize(question, args, options)
-    self.parser = question.parser
-    self.id = parser.new_dependency_id
-    if question.class == QuestionGroup
-      self.question_group_id = question.id
-    else
-      self.question_id = question.id
-    end
-    self.rule = (args[0] || {})[:rule]
-    self.dependency_conditions = []
-    self.default_options().merge(options).merge(args[1] || {}).each{|key,value| self.instance_variable_set("@#{key}", value)}
+  def parse_opts(opts)
+    {} # toss the method name and reference identifier by default
   end
-  
-  def default_options()
-    {}
-  end
-  
-  # Injecting the id of the current dependency object into the dependency_condition on assignment
-  def add_dependency_condition(dc_obj)
-    dc_obj.dependency_id = self.id
-    self.dependency_conditions << dc_obj
-  end
-  
-  def yml_attrs
-    instance_variables.sort - ["@parser", "@dependency_conditions", "@reference_identifier"]
-  end
-  def to_yml
-    out = [ %(#{@data_export_identifier}_#{@id}:) ]
-    yml_attrs.each{|a| out << "  #{a[1..-1]}: #{instance_variable_get(a).is_a?(String) ? "\"#{instance_variable_get(a)}\"" : instance_variable_get(a) }"}
-    (out << nil ).join("\r\n")
-  end
-
-  def to_file
-    File.open(self.parser.dependencies_yml, File::CREAT|File::APPEND|File::WRONLY) {|f| f << to_yml}
-    self.dependency_conditions.compact.map(&:to_file)  
-  end
-  
-  
 
 end

data/script/surveyor/dependency_condition.rb

@@ -1,4 +1,4 @@
-class DependencyCondition
+class DependencyCondition < SurveyParser::Base
 
   # Context, Conditional, Value
   attr_accessor :id, :dependency_id, :rule_key, :parser
@@ -6,58 +6,33 @@ class DependencyCondition
   attr_accessor :answer_id, :datetime_value, :integer_value, :float_value, :unit, :text_value, :string_value, :response_other
   attr_accessor :question_reference, :answer_reference
   
-  # id, dependency, and question_id required
-  def initialize(dependency, args, options)
-    self.parser = dependency.parser
-    self.id = parser.new_dependency_condition_id
-    self.dependency_id = dependency.id
-    args_options = parse_args_options(args)
-    self.default_options().merge(options).merge(args_options).each{|key,value| self.instance_variable_set("@#{key}", value)}
-  end
-  
-  def default_options()
+  def default_options
     { :operator => "==" }
   end
-  
-  def parse_args_options(args)
+  def parse_args(args)
     a0, a1, a2 = args
-    options = {:question_reference => a0.to_s.gsub("q_", ""), :operator => a1}
-    a2.is_a?(Hash) ? options.merge(a2) : options.merge({:answer_reference => a2.to_s.gsub("a_", "")})
-  end
-  
-  def yml_attrs
-    instance_variables.sort - ["@parser", "@question_reference", "@answer_reference", "@reference_identifier"]
+    {:question_reference => a0.to_s.gsub("q_", ""), :operator => a1}.merge(a2.is_a?(Hash) ? a2 : {:answer_reference => a2.to_s.gsub("a_", "")})
   end
-  def to_yml
-    out = [ %(#{@data_export_identifier}_#{@id}:) ]
-    yml_attrs.each{|a| out << "  #{a[1..-1]}: #{instance_variable_get(a).is_a?(String) ? "\"#{instance_variable_get(a)}\"" : instance_variable_get(a) }"}
-    (out << nil ).join("\r\n")
+  def parse_opts(opts)
+    {:rule_key => opts[:reference_identifier]}
   end
-
+  
   def reconcile_dependencies
     # Looking up references to questions and answers for linking the dependency objects
-    puts "Looking up references for question: #{@question_reference}"
-    ref_question = Survey.current_survey.find_question_by_reference(@question_reference) # TODO change this. Argh. I can't think of a better way to get a hold of this reference here...
-    if ref_question
-      puts "  found question: #{ref_question.data_export_identifier} (id:#{ref_question.id})"
+    print "Lookup Q ref #{@question_reference}:"
+    if (ref_question = parser.current_survey.find_question_by_reference(@question_reference))
+      print " found Q#{ref_question.id} "
       @question_id = ref_question.id
-      ref_answer = ref_question.find_answer_by_reference(@answer_reference)
-      if ref_answer 
+      print "Lookup A ref #{@answer_reference}"
+      if (ref_answer = ref_question.find_answer_by_reference(@answer_reference))
+        print " found A#{ref_answer.id} "
         @answer_id = ref_answer.id
       else
         raise "Could not find referenced answer #{@answer_reference}"
       end
-        
     else
       raise "Could not find referenced question #{@question_reference}"
     end
   end
 
-  def to_file
-    # Reconciling the references used in the dsl to actual object ids
-    #puts "Reconcile of dependency:"
-   # reconcile_dependencies    
-    File.open(self.parser.dependency_conditions_yml, File::CREAT|File::APPEND|File::WRONLY) {|f| f << to_yml}
-  end
-
 end

data/script/surveyor/question.rb

@@ -1,67 +1,33 @@
-require File.dirname(__FILE__) + '/columnizer'
-
-class Question
-  include Columnizer
-  
+class Question < SurveyParser::Base
   # Context, Content, Reference, Display, Children
   attr_accessor :id, :parser, :survey_section_id, :question_group_id
   attr_accessor :text, :short_text, :help_text, :pick
-  attr_accessor :reference_identifier, :data_export_identifier, :common_namespace, :common_identitier
+  attr_accessor :reference_identifier, :data_export_identifier, :common_namespace, :common_identifier
   attr_accessor :display_order, :display_type, :is_mandatory, :display_width, :custom_class, :custom_renderer
-  attr_accessor :answers, :dependency
+  attr_accessor :dependency
+  has_children :answers
 
-  def initialize(section, args, options)
-    self.parser = section.parser
-    self.id = parser.new_question_id
-    self.display_order = self.id
-    self.survey_section_id = section.id
-    self.text = args[0]
-    self.answers = []
-    self.dependency = nil
-    self.default_options(text).merge(options).merge(args[1] || {}).each{|key,value| self.instance_variable_set("@#{key}", value)}
-  end
-  
-  def default_options(text)
-    { :short_text => text,
-      :pick => :none,
+  def default_options
+    { :pick => :none,
       :display_type => :default,
       :is_mandatory => true,
-      :data_export_identifier => Columnizer.to_normalized_column(text)
+      :display_order => self.id
     }
   end
-  
-  # Injecting the id of this question object into the dependency object on assignment
-  def dependency=(dep)
-    unless dep.nil?
-      dep.question_id = self.id
-    end
-    @dependency = dep
+  def parse_opts(opts)
+    (name = opts.delete(:method_name)) =~ /label|image/ ? opts.merge(:display_type => name) : opts
   end
-  
-  def find_answer_by_reference(ref_id)
-    answer = nil
-    count = 0
-    puts "Looking up answer with ref: #{ref_id}"
-    while answer.nil? and count < self.answers.size
-      answer = self.answers[count] if self.answers[count].reference_identifier == ref_id
-      count += 1
-    end
-    puts "  found answer: '#{answer.text}' (id:#{answer.id})"  unless answer.nil?
-    answer
+  def parse_args(args)
+    text = args[0] || "Question"
+    {:text => text, :short_text => text, :data_export_identifier => Surveyor.to_normalized_string(text)}.merge(args[1] || {})
   end
   
-  def yml_attrs
-    instance_variables.sort - ["@parser", "@answers", "@dependency"]
-  end
-  def to_yml
-    out = [ %(#{@data_export_identifier}_#{@id}:) ]
-    yml_attrs.each{|a| out << "  #{a[1..-1]}: #{instance_variable_get(a).is_a?(String) ? "\"#{instance_variable_get(a)}\"" : instance_variable_get(a) }"}
-    (out << nil ).join("\r\n")
+  def find_answer_by_reference(ref_id)
+    self.answers.detect{|a| a.reference_identifier == ref_id}
   end
-  
+
   def to_file
-    File.open(self.parser.questions_yml, File::CREAT|File::APPEND|File::WRONLY){ |f| f << to_yml }
-    self.answers.compact.map(&:to_file)
+    super
     if self.dependency then self.dependency.to_file end
   end
 

data/script/surveyor/question_group.rb

@@ -1,5 +1,4 @@
-class QuestionGroup
-
+class QuestionGroup < SurveyParser::Base
   # Context, Content, Display, Children
   attr_accessor :id, :parser
   attr_accessor :text, :help_text
@@ -7,29 +6,18 @@ class QuestionGroup
   attr_accessor :display_type, :custom_class, :custom_renderer
   attr_accessor :dependency
 
-  # id, section and text required
-  def initialize(section, args, options)
-    self.parser = section.parser
-    self.id = parser.new_question_group_id
-    self.text = args[0]
-    self.default_options().merge(options).merge(args[1] || {}).each{|key,value| self.instance_variable_set("@#{key}", value)}
-  end
-  
-  def default_options()
+  def default_options
     {:display_type => "default"}
   end
-
-  def yml_attrs
-    instance_variables.sort - ["@parser", "@dependency"]
+  def parse_args(args)
+    {:text => args[0] || "Question Group"}.merge(args[1] || {})
   end
-  def to_yml
-    out = [ %(#{@id}:) ]
-    yml_attrs.each{|a| out << "  #{a[1..-1]}: #{instance_variable_get(a).is_a?(String) ? "\"#{instance_variable_get(a)}\"" : instance_variable_get(a) }"}
-    (out << nil ).join("\r\n")
+  def parse_opts(opts)
+    (name = opts.delete(:method_name)) =~ /grid|repeater/ ? opts.merge(:display_type => name) : opts
   end
 
   def to_file
-    File.open(self.parser.question_groups_yml, File::CREAT|File::APPEND|File::WRONLY){ |f| f << to_yml }
+    super
     if self.dependency then self.dependency.to_file end
   end
 

data/script/surveyor/specs/answer_spec.rb

@@ -1,66 +1,29 @@
-require File.dirname(__FILE__) + '/../answer'
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+require 'answer'
 
 describe Answer, " when first created" do
 
-  TEST_ID = 1
-  TEST_CONTEXT_ID = "b3a_1"
-  TEST_QUESTION_ID = "2"
-  TEST_TEXT = "No / Rarely"
-  TEST_OPTIONS = {:help_text => "Never or rarely ever"}
-
-  before do    
-    @ans = Answer.new(TEST_ID, TEST_QUESTION_ID, TEST_CONTEXT_ID, TEST_TEXT, TEST_OPTIONS)
+  before(:each) do
+    question = mock("Question", :id => 2, :parser => mock("Parser", :new_answer_id => 1))
+    question.stub!(:class => Question)
+    options = {:help_text => "Never or rarely ever", :reference_identifier => "b3a_1"}
+    @ans = Answer.new(question, ["No / Rarely"], options)
   end
   
   it "should set inititalized variables to those passed in" do
-    @ans.id.should == TEST_ID
-    @ans.question_id.should == TEST_QUESTION_ID
-    @ans.context_id.should == TEST_CONTEXT_ID
-    @ans.text.should == TEST_TEXT
-    @ans.help_text.should == TEST_OPTIONS[:help_text]
-    end
+    @ans.id.should == 1
+    @ans.question_id.should == 2
+    @ans.reference_identifier.should == "b3a_1"
+    @ans.text.should == "No / Rarely"
+    @ans.help_text.should == "Never or rarely ever"
+  end
   
   it "should output current state to yml" do
      @ans.should.respond_to?(:to_yml)
   end
-  
-  it "should create a normalized code from the answer text" do
-    # The answer object should take the title of the text and convert
-    # it to a code that is more appropirate for a database entry
-    
-    # Taking a few answers from the survey for testing
-    str = []
-    str[0] = "This? is a in - t3rrible-@nswer of! (question) on"
-    str[1] = "Private insurance/ HMO/ PPO"
-    str[2] = "VA"
-    str[3] = "PMS (Premenstrual syndrome)/ PMDD (Premenstrual Dysphoric Disorder)"
-    str[4] = "Have never been employed outside the home"
-    str[5] = "Professional"
-    str[6] = "Not working because of temporary disability, but expect to return to a job"
-    
-    # What the results should look like
-    r_str = []
-    r_str[0] = "this_t3rrible_nswer"
-    r_str[1] = "private_insurance_hmo_ppo"
-    r_str[2] = "va"
-    r_str[3] = "pms_pmdd"
-    r_str[4] = "never_been_employed_outside_home"
-    r_str[5] = "professional"
-    r_str[6] = "temporary_disability_expect_return_job"
-    
-    count = 0 
-    str.each do |s|
-       
-       code = Answer.to_normalized_code(s)  
-       code.should eql(r_str[count])
-       count += 1
-      
-    end
-    
-  end
-  
+
   it "should create a normalized code automatically when initalized" do
-    @ans.code.should eql("no_rarely")
+    @ans.data_export_identifier.should eql("no_rarely")
   end
   
 end

data/script/surveyor/specs/question_spec.rb

@@ -1,111 +1,63 @@
-require File.dirname(__FILE__) + '/../question'
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+require 'question'
 
 describe Question, " when first created" do
-  TEST_ID = 1
-  TEST_CONTEXT_ID = "B3"
-  TEST_SECTION_ID = 2
-  TEST_TEXT = "In the past 12 months how many times have you been to a doctor?"
-  TEST_HELP_TEXT = "Please give a rough estimate"
-  TEST_OPTIONS = {:help_text => TEST_HELP_TEXT }
-  TEST_CODE = "many_times_you_been_doctor"
-
   before do    
-    @ques = Question.new(TEST_ID, TEST_SECTION_ID, TEST_CONTEXT_ID, TEST_TEXT, TEST_OPTIONS)
+    section = mock("SurveySection", :id => 2, :parser => mock("Parser", :new_question_id => 1))
+    section.stub!(:class => SurveySection)
+    args = {:help_text => "Please give a rough estimate", :reference_identifier => "B3"}
+    options = {}
+    @ques = Question.new(section, ["In the past 12 months how many times have you been to a doctor?", args], options)
   end
   
   it "should set initialization parameters properly" do
-    @ques.id.should == TEST_ID
-    @ques.context_id.should == TEST_CONTEXT_ID
-    @ques.section_id.should == TEST_SECTION_ID
-    @ques.code.should == TEST_CODE
-    @ques.options[:help_text].should == TEST_HELP_TEXT
+    @ques.id.should == 1
+    @ques.reference_identifier.should == "B3"
+    @ques.survey_section_id.should == 2
+    @ques.help_text.should == "Please give a rough estimate"
     
     #Checking the defaults
-    @ques.options[:has_omit?].should == true
-    @ques.options[:has_other?].should == false
-    @ques.options[:answer_format].should == :medium_text
+    @ques.pick.should == :none
+    @ques.display_type.should == :default
+    @ques.is_mandatory.should == true
   end
 
   it "should output current state to yml" do
      @ques.should.respond_to?(:to_yml)
   end
-  
-  it "should create a normalized code from the answer text" do
-    # The question object should take the title of the text and convert
-    # it to a code that is more appropirate for a database entry
-    
-    # Taking a few questions from the survey for testing
-    str = []
-    str[0] = "How long has it been since you last visited a doctor for a routine checkup (routine being not for a particular reason)?"
-    str[1] = "Do you take medications as directed?"
-    str[2] = "Do you every leak urine (or) water when you didn't want to?" #checking for () and ' removal
-    str[3] = "Do your biological family members (not adopted) have a \"history\" of any of the following?"
-    str[4] = "Your health:"
-    str[5] = "In general, you would say your health is:"
-    
-    # What the results should look like
-    r_str = []
-    r_str[0] = "visited_doctor_for_routine_checkup"
-    r_str[1] = "you_take_medications_as_directed"
-    r_str[2] = "urine_water_you_didnt_want"
-    r_str[3] = "family_members_history_any_following"
-    r_str[4] = "your_health"
-    r_str[5] = "you_would_say_your_health"
-    
-    count = 0 
-    str.each do |s|
-       
-       code = Question.to_normalized_code(s)  
-       code.should eql(r_str[count])
-       count += 1
-      
-    end
-    
-  end
-  
+
   it "should create a normalized code automatically when initalized" do
-    @ques.code.should eql(TEST_CODE)
+    @ques.data_export_identifier.should eql("many_times_you_been_doctor")
   end
   
-  it "should update the normalized code if the title is changed" do
-    @ques.code.should eql(TEST_CODE)
-    @ques.text = "Sometimes or All the time?"
-    @ques.code.should eql("sometimes_all_time")
-  end
+  # We don't change titles via the DSL
+  # it "should update the normalized code if the title is changed" do
+  #   @ques.data_export_identifier.should == "many_times_you_been_doctor"
+  #   @ques.text = "Sometimes or All the time?"
+  #   @ques.data_export_identifier.should == "sometimes_all_time"
+  # end
 
 end
 
-describe Question, " when it contains data" do
-  
-  before do # Mocking up some answers
-    @question = Question.new(1,TEST_SECTION_ID,TEST_CONTEXT_ID,TEST_TEXT,TEST_OPTIONS)
-    ma1 = mock("answer")
-    ma1.stub!(:context_id).and_return("1")
-    @question.add_answer(ma1)
-    
-    ma2 = mock("answer")
-    ma2.stub!(:context_id).and_return("2")
-    @question.add_answer(ma2)
-    
-    ma3 = mock("answer")
-    ma3.stub!(:context_id).and_return("3")
-    @question.add_answer(ma3)
-    
+describe Question, "when it contains data" do
+  before(:each) do
+    section = mock("SurveySection", :id => 2, :parser => mock("Parser", :new_question_id => 1))
+    args = {:help_text => "Please give a rough estimate", :reference_identifier => "B3"}
+    options = {}
+    @ques = Question.new(section, ["In the past 12 months how many times have you been to a doctor?", args], options)
+    @ques.answers << mock("Answer", :reference_identifier => "1", :text => "foo")
+    @ques.answers << mock("Answer", :reference_identifier => "2", :text => "foo")
+    @ques.answers << mock("Answer", :reference_identifier => "3", :text => "foo")
   end
-  
+
   it "should have added the test answers correctly" do
-    @question.answers.length.should eql(3)
-  end
-  
-  it "should have a question text" do
-    @question.text.should eql(TEST_TEXT)
+    @ques.answers.length.should eql(3)
   end
   
-  it "should find an answer by context_id" do
-    pending # yoon: commented out during dsl refactoring
-    a_to_find = @question.find_answer_by_context_id("2")
-    a_to_find.should_not eql(nil)
-    a_to_find.context_id.should eql("2")
+  it "should find an answer by reference" do
+    a_to_find = @ques.find_answer_by_reference("2")
+    a_to_find.should_not be_nil
+    a_to_find.reference_identifier.should eql("2")
   end
   
 end