surveyor_gui 0.0.3

data/spec/lib/rake_kitchen_sink.rb

@@ -0,0 +1,42 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+require 'rake'
+
+describe Surveyor::Parser do
+  before do
+    @rake = Rake::Application.new
+    Rake.application = @rake
+    Rake.application.add_import "#{gem_path('surveyor')}/lib/tasks/surveyor_tasks.rake"
+    Rake.application.load_imports
+    Rake::Task.define_task(:environment)
+  end
+  it "should return properly parse the kitchen sink survey" do
+    ENV["FILE"]="surveys/kitchen_sink_survey.rb"
+    @rake["surveyor"].invoke
+
+    Survey.count.should == 1
+    SurveySection.count.should == 2
+    Question.count.should == 51
+    Answer.count.should == 252
+    Dependency.count.should == 8
+    DependencyCondition.count.should == 12
+    QuestionGroup.count.should == 6
+
+    Survey.all.map(&:destroy)
+  end
+  it "should return properly parse a UTF8 survey" do
+    pending "failing - not clear why - await update of surveyor"
+    ENV["FILE"]="../spec/fixtures/chinese_survey.rb"
+    @rake["surveyor"].invoke
+
+    Survey.count.should == 1
+    SurveySection.count.should == 1
+    Question.count.should == 3
+    Answer.count.should == 15
+    Dependency.count.should == 0
+    DependencyCondition.count.should == 0
+    QuestionGroup.count.should == 1
+
+    Survey.all.map(&:destroy)
+  end
+
+end

data/spec/lib/redcap_parser_spec.rb

@@ -0,0 +1,129 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe Surveyor::RedcapParser do
+  let(:parser){ Surveyor::RedcapParser.new }
+  it "returns a survey object" do
+    x = %("Variable / Field Name","Form Name","Field Units","Section Header","Field Type","Field Label","Choices OR Calculations","Field Note","Text Validation Type","Text Validation Min","Text Validation Max",Identifier?,"Branching Logic (Show field only if...)","Required Field?"\nstudy_id,demographics,,,text,"Study ID",,,,,,,,)
+    parser.parse(x, "redcaptest").is_a?(Survey).should be_true
+  end
+  context "parses" do
+    it "basic questions from REDCap" do
+      file = "REDCapDemoDatabase_DataDictionary.csv"
+      parser.parse File.read(File.join(Rails.root, '..', 'spec', 'fixtures', file)), file
+      expect(Survey.count).to eq(1)
+      expect(Question.count).to eq(143)
+      expect(Answer.count).to eq(233)
+      expect(Dependency.count).to eq(2)
+      expect(DependencyCondition.count).to eq(3)
+      dependencies = [{rule: "A", question_reference_identifier: "given_birth"},
+                       {rule: "A and B", question_reference_identifier: "num_children"}]
+      dependencies.each{|attrs| (expect(Dependency.where(rule: attrs[:rule]).first.question.reference_identifier).to eq(attrs[:question_reference_identifier])) if attrs[:question_reference_identifier] }
+      dependency_conditions_a =  [{rule_key: "A", operator: "==", question_reference_identifier: "sex", answer_reference_identifier: "0"}]
+      dependency_conditions_ab = [{rule_key: "A", operator: "==", question_reference_identifier: "sex", answer_reference_identifier: "0"},
+                                  {rule_key: "B", operator: "==", question_reference_identifier: "given_birth", answer_reference_identifier: "1"}]
+      dependency_conditions_a.each{|attrs| (expect(Dependency.where(rule: "A").first.dependency_conditions.where(rule_key: attrs[:rule_key]).first.answer.reference_identifier).to eq(attrs[:answer_reference_identifier])) if attrs[:answer_reference_identifier] }
+      dependency_conditions_a.each{|attrs| (expect(Dependency.where(rule: "A").first.dependency_conditions.where(rule_key: attrs[:rule_key]).first.question.reference_identifier).to eq(attrs[:question_reference_identifier])) if attrs[:question_reference_identifier] }
+      dependency_conditions_a.each{|attrs| (expect(Dependency.where(rule: "A").first.dependency_conditions.where(rule_key: attrs[:rule_key]).first.operator).to eq(attrs[:operator])) if attrs[:operator] }
+      dependency_conditions_ab.each{|attrs| (expect(Dependency.where(rule: "A and B").first.dependency_conditions.where(rule_key: attrs[:rule_key]).first.answer.reference_identifier).to eq(attrs[:answer_reference_identifier])) if attrs[:answer_reference_identifier] }
+      dependency_conditions_ab.each{|attrs| (expect(Dependency.where(rule: "A and B").first.dependency_conditions.where(rule_key: attrs[:rule_key]).first.question.reference_identifier).to eq(attrs[:question_reference_identifier])) if attrs[:question_reference_identifier] }
+      dependency_conditions_ab.each{|attrs| (expect(Dependency.where(rule: "A and B").first.dependency_conditions.where(rule_key: attrs[:rule_key]).first.operator).to eq(attrs[:operator])) if attrs[:operator] }
+    end
+    it "question level dependencies from REDCap" do
+      file = "redcap_siblings.csv"
+      parser.parse File.read(File.join(Rails.root, '..', 'spec', 'fixtures', file)), file
+      expect(Dependency.count).to eq(1)
+      expect(DependencyCondition.count).to eq(1)
+      dependencies = [{rule: "A", question_reference_identifier: "sib1yob"}]
+      dependencies.each{|attrs| (expect(Dependency.where(rule: attrs[:rule]).first.question.reference_identifier).to eq(attrs[:question_reference_identifier])) if attrs[:question_reference_identifier] }
+      dependency_conditions =  [{rule_key: "A", operator: ">", question_reference_identifier: "sibs"}]
+      dependency_conditions.each{|attrs| (expect(Dependency.where(rule: "A").first.dependency_conditions.where(rule_key: attrs[:rule_key]).first.question.reference_identifier).to eq(attrs[:question_reference_identifier])) if attrs[:question_reference_identifier] }
+      dependency_conditions.each{|attrs| (expect(Dependency.where(rule: "A").first.dependency_conditions.where(rule_key: attrs[:rule_key]).first.operator).to eq(attrs[:operator])) if attrs[:operator] }
+    end
+    it "different headers from REDCap" do
+      file = "redcap_new_headers.csv"
+      parser.parse File.read(File.join(Rails.root, '..', 'spec', 'fixtures', file)), file
+      expect(Survey.count).to eq(1)
+      expect(Question.count).to eq(1)
+      expect(Answer.count).to eq(2)
+    end
+    it "different whitespace from REDCap" do
+      file = "redcap_whitespace.csv"
+      parser.parse File.read(File.join(Rails.root, '..', 'spec', 'fixtures', file)), file
+      expect(Survey.count).to eq(1)
+      expect(Question.count).to eq(2)
+      expect(Answer.count).to eq(7)
+      answers = [{reference_identifier: "1", text: "Lexapro"},
+                 {reference_identifier: "2", text: "Celexa"},
+                 {reference_identifier: "3", text: "Prozac"},
+                 {reference_identifier: "4", text: "Paxil"},
+                 {reference_identifier: "5", text: "Zoloft"},
+                 {reference_identifier: "0", text: "No"},
+                 {reference_identifier: "1", text: "Yes"}]
+      answers.each{|attrs| (expect(Answer.where(text: attrs[:text]).first.reference_identifier).to eq(attrs[:reference_identifier]))}
+    end
+  end
+  context "helper methods" do
+    it "requires specific columns" do
+      # with standard fields
+      x = %w(field_units choices_or_calculations text_validation_type variable__field_name form_name  section_header field_type field_label field_note text_validation_min text_validation_max identifier branching_logic_show_field_only_if required_field)
+      parser.missing_columns(x).should be_blank
+      # without field_units
+      y = %w(choices_or_calculations text_validation_type variable__field_name form_name  section_header field_type field_label field_note text_validation_min text_validation_max identifier branching_logic_show_field_only_if required_field)
+      parser.missing_columns(y).should be_blank
+      # choices_or_calculations => choices_calculations_or_slider_labels
+      z = %w(field_units choices_calculations_or_slider_labels text_validation_type variable__field_name form_name  section_header field_type field_label field_note text_validation_min text_validation_max identifier branching_logic_show_field_only_if required_field)
+      parser.missing_columns(z).should be_blank
+      # text_validation_type => text_validation_type_or_show_slider_number
+      a = %w(field_units choices_or_calculations text_validation_type_or_show_slider_number variable__field_name form_name  section_header field_type field_label field_note text_validation_min text_validation_max identifier branching_logic_show_field_only_if required_field)
+      parser.missing_columns(a).should be_blank
+    end
+    it "decomposes dependency rules" do
+      # basic
+      Dependency.new.extend(SurveyorRedcapParserDependencyMethods).decompose_rule('[f1_q12]="1"').should == {:rule => "A", :components => ['[f1_q12]="1"']}
+      # spacing
+      Dependency.new.extend(SurveyorRedcapParserDependencyMethods).decompose_rule('[f1_q9] = "1"').should == {:rule => "A", :components => ['[f1_q9] = "1"']}
+      # and
+      Dependency.new.extend(SurveyorRedcapParserDependencyMethods).decompose_rule('[pre_q88]="1" and [pre_q90]="1"').should == {:rule => "A and B", :components => ['[pre_q88]="1"', '[pre_q90]="1"']}
+      # or
+      Dependency.new.extend(SurveyorRedcapParserDependencyMethods).decompose_rule('[second_q111]="1" or [second_q111]="3"').should == {:rule => "A or B", :components => ['[second_q111]="1"', '[second_q111]="3"']}
+      # or and
+      Dependency.new.extend(SurveyorRedcapParserDependencyMethods).decompose_rule('[second_q100]="1" or [second_q100]="3" and [second_q101]="1"').should == {:rule => "A or B and C", :components => ['[second_q100]="1"', '[second_q100]="3"', '[second_q101]="1"']}
+      # and or
+      Dependency.new.extend(SurveyorRedcapParserDependencyMethods).decompose_rule('[second_q4]="1" and [second_q11]="1" or [second_q11]="98"').should == {:rule => "A and B or C", :components => ['[second_q4]="1"', '[second_q11]="1"', '[second_q11]="98"']}
+      # or or or
+      Dependency.new.extend(SurveyorRedcapParserDependencyMethods).decompose_rule('[pre_q74]="1" or [pre_q74]="2" or [pre_q74]="4" or [pre_q74]="5"').should == {:rule => "A or B or C or D", :components => ['[pre_q74]="1"', '[pre_q74]="2"', '[pre_q74]="4"', '[pre_q74]="5"']}
+      # and with different operator
+      Dependency.new.extend(SurveyorRedcapParserDependencyMethods).decompose_rule('[f1_q15] >= 21 and [f1_q28] ="1"').should == {:rule => "A and B", :components => ['[f1_q15] >= 21', '[f1_q28] ="1"']}
+    end
+    it "decomposes nested dependency rules" do
+      # external parenthesis
+      Dependency.new.extend(SurveyorRedcapParserDependencyMethods).decompose_rule('([pre_q74]="1" or [pre_q74]="2" or [pre_q74]="4" or [pre_q74]="5") and [pre_q76]="2"').should == {:rule => "(A or B or C or D) and E", :components => ['[pre_q74]="1"', '[pre_q74]="2"', '[pre_q74]="4"', '[pre_q74]="5"', '[pre_q76]="2"']}
+      # internal parenthesis
+      Dependency.new.extend(SurveyorRedcapParserDependencyMethods).decompose_rule('[f1_q10(4)]="1"').should == {:rule => "A", :components => ['[f1_q10(4)]="1"']}
+      # internal and external parenthesis
+      Dependency.new.extend(SurveyorRedcapParserDependencyMethods).decompose_rule('([f1_q7(11)] = "1" or [initial_52] = "1") and [pre_q76]="2"').should == {:rule => "(A or B) and C", :components => ['[f1_q7(11)] = "1"', '[initial_52] = "1"', '[pre_q76]="2"']}
+    end
+    it "decomposes shortcut dependency rules" do
+      # 'or' on the right of the operator
+      Dependency.new.extend(SurveyorRedcapParserDependencyMethods).decompose_rule('[initial_108] = "1" or "2"').should == {:rule => "A or B", :components => ['[initial_108] = "1"', '[initial_108] = "2"']}
+      # multiple 'or' on the right
+      Dependency.new.extend(SurveyorRedcapParserDependencyMethods).decompose_rule('[initial_52] = "1" or "2" or "3"').should == {:rule => "A or B or C", :components => ['[initial_52] = "1"', '[initial_52] = "2"', '[initial_52] = "3"']}
+      # commas on the right
+      Dependency.new.extend(SurveyorRedcapParserDependencyMethods).decompose_rule('[initial_189] = "1, 2, 3"').should == {:rule => "(A and B and C)", :components => ['[initial_189] = "1"', '[initial_189] = "2"', '[initial_189] = "3"']}
+      # multiple internal parenthesis on the left
+      Dependency.new.extend(SurveyorRedcapParserDependencyMethods).decompose_rule('[initial_119(1)(2)(3)(4)(5)] = "1"').should == {:rule => "(A and B and C and D and E)", :components => ['[initial_119(1)] = "1"', '[initial_119(2)] = "1"', '[initial_119(3)] = "1"', '[initial_119(4)] = "1"', '[initial_119(5)] = "1"']}
+    end
+    it "decomposes components" do
+      Dependency.new.extend(SurveyorRedcapParserDependencyMethods).decompose_component('[initial_52] = "1"').should == {:question_reference => 'initial_52', :operator => '==', :answer_reference => '1'}
+      Dependency.new.extend(SurveyorRedcapParserDependencyMethods).decompose_component('[initial_119(2)] = "1"').should == {:question_reference => 'initial_119', :operator => '==', :answer_reference => '2'}
+      Dependency.new.extend(SurveyorRedcapParserDependencyMethods).decompose_component('[f1_q15] >= 21').should == {:question_reference => 'f1_q15', :operator => '>=', :integer_value => '21'}
+      # basic, blanks
+      Dependency.new.extend(SurveyorRedcapParserDependencyMethods).decompose_component("[f1_q15]=''").should == {:question_reference => 'f1_q15', :operator => '==', :answer_reference => ''}
+      # basic, negatives
+      Dependency.new.extend(SurveyorRedcapParserDependencyMethods).decompose_component("[f1_q15]='-2'").should == {:question_reference => 'f1_q15', :operator => '==', :answer_reference => '-2'}
+      # internal parenthesis
+      Dependency.new.extend(SurveyorRedcapParserDependencyMethods).decompose_component("[hiprep_heat2(97)] = '1'").should == {:question_reference => 'hiprep_heat2', :operator => '==', :answer_reference => '97'}
+      Dependency.new.extend(SurveyorRedcapParserDependencyMethods).decompose_component("[hi_event1_type] <> ''").should == {:question_reference => 'hi_event1_type', :operator => '!=', :answer_reference => ''}
+    end
+  end
+end

data/spec/lib/unparser_spec.rb

@@ -0,0 +1,126 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe Surveyor::Unparser do
+  before(:each) do
+    @survey = Survey.new(:title => "Simple survey", :description => "very simple")
+    @section = @survey.sections.build(:title => "Simple section")
+  end
+  
+  it "should unparse a basic survey, section, and question" do
+    q1 = @section.questions.build(:text => "What is your favorite color?", :reference_identifier => 1, :pick => :one)
+    a11 = q1.answers.build(:text => "red", :response_class => "answer", :reference_identifier => 1, :question => q1)
+    a12 = q1.answers.build(:text => "green", :response_class => "answer", :reference_identifier => 2, :question => q1)
+    a13 = q1.answers.build(:text => "blue", :response_class => "answer", :reference_identifier => 3, :question => q1)
+    a14 = q1.answers.build(:text => "Other", :response_class => "string", :reference_identifier => 4, :question => q1)
+    a15 = q1.answers.build(:text => "Omit", :reference_identifier => 5, :question => q1, :is_exclusive => true)
+    q2 = @section.questions.build(:text => "What is your name?", :reference_identifier => 2, :pick => :none)
+    a21 = q2.answers.build(:response_class => "string", :reference_identifier => 1, :question => q2)
+    Surveyor::Unparser.unparse(@survey).should ==
+<<-dsl
+survey "Simple survey", :description=>"very simple" do
+  section "Simple section" do
+
+    q_1 "What is your favorite color?", :pick=>"one"
+    a_1 "red"
+    a_2 "green"
+    a_3 "blue"
+    a_4 :other, :string
+    a_5 :omit
+
+    q_2 "What is your name?"
+    a_1 :string
+  end
+end
+dsl
+  end
+  
+  it "should unparse groups" do
+    q3 = @section.questions.build(:text => "Happy?")    
+    a31 = q3.answers.build(:text => "Yes", :question => q3)
+    a32 = q3.answers.build(:text => "Maybe", :question => q3)
+    a33 = q3.answers.build(:text => "No", :question => q3)
+    
+    q4 = @section.questions.build(:text => "Energized?")
+    a41 = q4.answers.build(:text => "Yes", :question => q4)
+    a42 = q4.answers.build(:text => "Maybe", :question => q4)
+    a43 = q4.answers.build(:text => "No", :question => q4)
+    
+    g1 = q3.build_question_group(:text => "How are you feeling?", :display_type => "grid")
+    q4.question_group = g1
+    g1.questions = [q3, q4]
+    
+    q5 = @section.questions.build(:text => "Model")    
+    a51 = q5.answers.build(:response_class => "string", :question => q3)
+    
+    g2 = q5.build_question_group(:text => "Tell us about the cars you own", :display_type => "repeater")
+    g2.questions = [q5]
+    
+    Surveyor::Unparser.unparse(@survey).should ==
+<<-dsl
+survey "Simple survey", :description=>"very simple" do
+  section "Simple section" do
+
+    grid "How are you feeling?" do
+      a "Yes"
+      a "Maybe"
+      a "No"
+      q "Happy?"
+      q "Energized?"
+    end
+
+    repeater "Tell us about the cars you own" do
+      q "Model"
+      a :string
+    end
+  end
+end
+dsl
+  end
+  
+  it "should unparse a basic survey, section, and question" do
+    q6 = @section.questions.build(:text => "What... is your name? (e.g. It is 'Arthur', King of the Britons)", :reference_identifier => "montypython3")
+    a61 = q6.answers.build(:response_class => "string", :reference_identifier => 1, :question => q6)
+    
+    q7 = @section.questions.build(:text => "What... is your quest? (e.g. To seek the Holy Grail)", :display_type => "label")
+    d1 = q7.build_dependency(:rule => "A", :question => q7)
+    dc1 = d1.dependency_conditions.build(:dependency => d1, :question => q6, :answer => a61, :operator => "==", :string_value => "It is 'Arthur', King of the Britons", :rule_key => "A")
+    
+    q8 = @section.questions.build(:text => "How many pets do you own?")
+    a81 = q8.answers.build(:response_class => "integer", :question => q8)
+    v1 = a81.validations.build(:rule => "A", :answer => a81)
+    vc1 = v1.validation_conditions.build(:operator => ">=", :integer_value => 0, :validation => v1, :rule_key => "A")
+
+    q9 = @section.questions.build(:text => "Pick your favorite date AND time", :custom_renderer => "/partials/custom_question")
+    a91 = q9.answers.build(:response_class => "datetime", :question => q9)
+
+    q10 = @section.questions.build(:text => "What time do you usually take a lunch break?", :reference_identifier => "time_lunch")
+    a101 = q10.answers.build(:response_class => "time", :reference_identifier => 1, :question => q10)
+
+    Surveyor::Unparser.unparse(@survey).should ==
+<<-dsl
+survey "Simple survey", :description=>"very simple" do
+  section "Simple section" do
+
+    q_montypython3 "What... is your name? (e.g. It is 'Arthur', King of the Britons)"
+    a_1 :string
+
+    label "What... is your quest? (e.g. To seek the Holy Grail)"
+    dependency :rule=>"A"
+    condition_A :q_montypython3, "==", {:string_value=>"It is 'Arthur', King of the Britons", :answer_reference=>"1"}
+
+    q "How many pets do you own?"
+    a :integer
+    validation :rule=>"A"
+    condition_A ">=", :integer_value=>0
+
+    q "Pick your favorite date AND time", :custom_renderer=>"/partials/custom_question"
+    a :datetime
+
+    q_time_lunch "What time do you usually take a lunch break?"
+    a_1 :time
+  end
+end
+dsl
+  end
+end
+

data/spec/models/answer_spec.rb

@@ -0,0 +1,144 @@
+# encoding: UTF-8
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe Answer do
+  let(:answer){ FactoryGirl.create(:answer) }
+
+  context "when creating" do
+    it { answer.should be_valid }
+    it "deletes validation when deleted" do
+      v_id = FactoryGirl.create(:validation, :answer => answer).id
+      answer.destroy
+      Validation.find_by_id(v_id).should be_nil
+    end
+  end
+
+  context "with mustache text substitution" do
+    require 'mustache'
+    let(:mustache_context){ Class.new(::Mustache){ def site; "Northwestern"; end; def foo; "bar"; end } }
+    it "subsitutes Mustache context variables" do
+      answer.text = "You are in {{site}}"
+      answer.in_context(answer.text, mustache_context).should == "You are in Northwestern"
+      answer.text_for(nil, mustache_context).should == "You are in Northwestern"
+
+      answer.help_text = "{{site}} is your site"
+      answer.in_context(answer.help_text, mustache_context).should == "Northwestern is your site"
+      answer.help_text_for(mustache_context).should == "Northwestern is your site"
+
+      answer.default_value = "{{site}}"
+      answer.in_context(answer.default_value, mustache_context).should == "Northwestern"
+      answer.default_value_for(mustache_context).should == "Northwestern"
+    end
+  end
+
+  context "with translations" do
+    require 'yaml'
+    let(:survey){ FactoryGirl.create(:survey) }
+    let(:survey_section){ FactoryGirl.create(:survey_section) }
+    let(:survey_translation){
+      FactoryGirl.create(:survey_translation, :locale => :es, :translation => {
+        :questions => {
+          :name => {
+            :answers => {
+              :name => {
+                :help_text => "Mi nombre es..."
+              }
+            }
+          }
+        }
+      }.to_yaml)
+    }
+    let(:question){ FactoryGirl.create(:question, :reference_identifier => "name") }
+    before do
+      answer.reference_identifier = "name"
+      answer.help_text = "My name is..."
+      answer.text = nil
+      answer.question = question
+      question.survey_section = survey_section
+      survey_section.survey = survey
+      survey.translations << survey_translation
+    end
+    it "returns its own translation" do
+      answer.translation(:es)[:help_text].should == "Mi nombre es..."
+    end
+    it "returns translations in views" do
+      answer.help_text_for(nil, :es).should == "Mi nombre es..."
+    end
+    it "returns its own default values" do
+      answer.translation(:de).should == {"text" => nil, "help_text" => "My name is...", "default_value" => nil}
+    end
+    it "returns default values in views" do
+      answer.help_text_for(nil, :de).should == "My name is..."
+    end
+  end
+
+  context "handling strings" do
+    it "#split preserves strings" do
+      answer.split(answer.text).should == "My favorite color is clear"
+    end
+    it "#split(:pre) preserves strings" do
+      answer.split(answer.text, :pre).should == "My favorite color is clear"
+    end
+    it "#split(:post) preserves strings" do
+      answer.split(answer.text, :post).should == ""
+    end
+    it "#split splits strings" do
+      answer.text = "before|after|extra"
+      answer.split(answer.text).should == "before|after|extra"
+    end
+    it "#split(:pre) splits strings" do
+      answer.text = "before|after|extra"
+      answer.split(answer.text, :pre).should == "before"
+    end
+    it "#split(:post) splits strings" do
+      answer.text = "before|after|extra"
+      answer.split(answer.text, :post).should == "after|extra"
+    end
+  end
+
+  context "for views" do
+    it "#text_for with #display_type == image" do
+      answer.text = "rails.png"
+      answer.display_type = :image
+      answer.text_for.should =~ /<img alt="Rails" src="\/(images|assets)\/rails\.png" \/>/
+    end
+    it "#text_for with #display_type == hidden_label" do
+      answer.text = "Red"
+      answer.text_for.should == "Red"
+      answer.display_type = "hidden_label"
+      answer.text_for.should == ""
+    end
+    it "#default_value_for"
+    it "#help_text_for"
+    it "reports DOM ready #css_class from #custom_class" do
+      answer.custom_class = "foo bar"
+      answer.css_class.should == "foo bar"
+    end
+    it "reports DOM ready #css_class from #custom_class and #is_exclusive" do
+      answer.custom_class = "foo bar"
+      answer.is_exclusive = true
+      answer.css_class.should == "exclusive foo bar"
+    end
+    it "#text_for preserves strings" do
+      answer.text_for.should == "My favorite color is clear"
+    end
+    it "#text_for(:pre) preserves strings" do
+      answer.text_for(:pre).should == "My favorite color is clear"
+    end
+    it "#text_for(:post) preserves strings" do
+      answer.text_for(:post).should == ""
+    end
+    it "#text_for splits strings" do
+      answer.text = "before|after|extra"
+      answer.text_for.should == "before|after|extra"
+    end
+    it "#text_for(:pre) splits strings" do
+      answer.text = "before|after|extra"
+      answer.text_for(:pre).should == "before"
+    end
+    it "#text_for(:post) splits strings" do
+      answer.text = "before|after|extra"
+      answer.text_for(:post).should == "after|extra"
+    end
+  end
+end

data/spec/models/dependency_condition_spec.rb

@@ -0,0 +1,428 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+
+describe DependencyCondition do
+  it "should have a list of operators" do
+    %w(== != < > <= >=).each do |operator|
+      DependencyCondition.operators.include?(operator).should be_true
+    end
+  end
+
+  describe "instance" do
+    before(:each) do
+      @dependency_condition = DependencyCondition.new(
+        :dependency_id => 1, :question_id => 45, :operator => "==",
+        :answer_id => 23, :rule_key => "A")
+    end
+
+    it "should be valid" do
+      @dependency_condition.should be_valid
+    end
+
+    it "should be invalid without a parent dependency_id, question_id" do
+      # this causes issues with building and saving
+      # @dependency_condition.dependency_id = nil
+      # @dependency_condition.should have(1).errors_on(:dependency_id)
+      # @dependency_condition.question_id = nil
+      # @dependency_condition.should have(1).errors_on(:question_id)
+    end
+
+    it "should be invalid without an operator" do
+      @dependency_condition.operator = nil
+      @dependency_condition.should have(2).errors_on(:operator)
+    end
+
+    it "should be invalid without a rule_key" do
+      @dependency_condition.should be_valid
+      @dependency_condition.rule_key = nil
+      @dependency_condition.should_not be_valid
+      @dependency_condition.should have(1).errors_on(:rule_key)
+    end
+
+    it "should have unique rule_key within the context of a dependency" do
+      @dependency_condition.should be_valid
+      DependencyCondition.create(
+        :dependency_id => 2, :question_id => 46, :operator => "==",
+        :answer_id => 14, :rule_key => "B")
+      @dependency_condition.rule_key = "B" # rule key uniquness is scoped by dependency_id
+      @dependency_condition.dependency_id = 2
+      @dependency_condition.should_not be_valid
+      @dependency_condition.should have(1).errors_on(:rule_key)
+    end
+
+    it "should have an operator in DependencyCondition.operators" do
+      DependencyCondition.operators.each do |o|
+        @dependency_condition.operator = o
+        @dependency_condition.should have(0).errors_on(:operator)
+      end
+      @dependency_condition.operator = "#"
+      @dependency_condition.should have(1).error_on(:operator)
+    end
+    it "should have a properly formed count operator" do
+      %w(count>1 count<1 count>=1 count<=1 count==1 count!=1).each do |o|
+        @dependency_condition.operator = o
+        @dependency_condition.should have(0).errors_on(:operator)
+      end
+      %w(count> count< count>= count<= count== count!=).each do |o|
+        @dependency_condition.operator = o
+        @dependency_condition.should have(1).errors_on(:operator)
+      end
+      %w(count=1 count><1 count<>1 count!1 count!!1 count=>1 count=<1).each do |o|
+        @dependency_condition.operator = o
+        @dependency_condition.should have(1).errors_on(:operator)
+      end
+      %w(count= count>< count<> count! count!! count=> count=< count> count< count>= count<= count== count!=).each do |o|
+        @dependency_condition.operator = o
+        @dependency_condition.should have(1).errors_on(:operator)
+      end
+    end
+  end
+
+  it "returns true for != with no responses" do
+    question = FactoryGirl.create(:question)
+    dependency_condition = FactoryGirl.create(:dependency_condition, :rule_key => "C", :question => question)
+    rs = FactoryGirl.create(:response_set)
+    dependency_condition.to_hash(rs).should == {:C => false}
+  end
+
+
+  it "should not assume that Response#as is not nil" do
+    # q_HEIGHT_FT "Portion of height in whole feet (e.g., 5)",
+    # :pick=>:one
+    # a :integer
+    # a_neg_1 "Refused"
+    # a_neg_2 "Don't know"
+    # label "Provided value is outside of the suggested range (4 to 7 feet). This value is admissible, but you may wish to verify."
+    # dependency :rule=>"A or B"
+    # condition_A :q_HEIGHT_FT, "<", {:integer_value => "4"}
+    # condition_B :q_HEIGHT_FT, ">", {:integer_value => "7"}
+
+    answer = FactoryGirl.create(:answer, :response_class => :integer)
+    @dependency_condition = DependencyCondition.new(
+      :dependency => FactoryGirl.create(:dependency),
+      :question => answer.question,
+      :answer => answer,
+      :operator => ">",
+      :integer_value => 4,
+      :rule_key => "A")
+
+    response = FactoryGirl.create(:response, :answer => answer, :question => answer.question)
+    response_set = response.response_set
+    response.integer_value.should == nil
+
+    @dependency_condition.to_hash(response_set).should == {:A => false}
+  end
+
+  describe "evaluate '==' operator" do
+    before(:each) do
+      @a = FactoryGirl.create(:answer, :response_class => "answer")
+      @b = FactoryGirl.create(:answer, :question => @a.question)
+      @r = FactoryGirl.create(:response, :question => @a.question, :answer => @a)
+      @rs = @r.response_set
+      @dc = FactoryGirl.create(:dependency_condition, :question => @a.question, :answer => @a, :operator => "==", :rule_key => "D")
+      @dc.as(:answer).should == @r.as(:answer)
+    end
+
+    it "with checkbox/radio type response" do
+      @dc.to_hash(@rs).should == {:D => true}
+      @dc.answer = @b
+      @dc.to_hash(@rs).should == {:D => false}
+    end
+
+    it "with string value response" do
+      @a.update_attributes(:response_class => "string")
+      @r.update_attributes(:string_value => "hello123")
+      @dc.string_value = "hello123"
+      @dc.to_hash(@rs).should == {:D => true}
+      @r.update_attributes(:string_value => "foo_abc")
+      @dc.to_hash(@rs).should == {:D => false}
+    end
+
+    it "with a text value response" do
+      @a.update_attributes(:response_class => "text")
+      @r.update_attributes(:text_value => "hello this is some text for comparison")
+      @dc.text_value = "hello this is some text for comparison"
+      @dc.to_hash(@rs).should == {:D => true}
+      @r.update_attributes(:text_value => "Not the same text")
+      @dc.to_hash(@rs).should == {:D => false}
+    end
+
+    it "with an integer value response" do
+      @a.update_attributes(:response_class => "integer")
+      @r.update_attributes(:integer_value => 10045)
+      @dc.integer_value = 10045
+      @dc.to_hash(@rs).should == {:D => true}
+      @r.update_attributes(:integer_value => 421)
+      @dc.to_hash(@rs).should == {:D => false}
+    end
+
+    it "with a float value response" do
+      @a.update_attributes(:response_class => "float")
+      @r.update_attributes(:float_value => 121.1)
+      @dc.float_value = 121.1
+      @dc.to_hash(@rs).should == {:D => true}
+      @r.update_attributes(:float_value => 130.123)
+      @dc.to_hash(@rs).should == {:D => false}
+    end
+  end
+
+  describe "evaluate '!=' operator" do
+    before(:each) do
+      @a = FactoryGirl.create(:answer)
+      @b = FactoryGirl.create(:answer, :question => @a.question)
+      @r = FactoryGirl.create(:response, :question => @a.question, :answer => @a)
+      @rs = @r.response_set
+      @dc = FactoryGirl.create(:dependency_condition, :question => @a.question, :answer => @a, :operator => "!=", :rule_key => "E")
+      @dc.as(:answer).should == @r.as(:answer)
+    end
+
+    it "with checkbox/radio type response" do
+      @dc.to_hash(@rs).should == {:E => false}
+      @dc.answer_id = @a.id.to_i+1
+      @dc.to_hash(@rs).should == {:E => true}
+    end
+
+    it "with string value response" do
+      @a.update_attributes(:response_class => "string")
+      @r.update_attributes(:string_value => "hello123")
+      @dc.string_value = "hello123"
+      @dc.to_hash(@rs).should == {:E => false}
+      @r.update_attributes(:string_value => "foo_abc")
+      @dc.to_hash(@rs).should == {:E => true}
+    end
+
+    it "with a text value response" do
+      @a.update_attributes(:response_class => "text")
+      @r.update_attributes(:text_value => "hello this is some text for comparison")
+      @dc.text_value = "hello this is some text for comparison"
+      @dc.to_hash(@rs).should == {:E => false}
+      @r.update_attributes(:text_value => "Not the same text")
+      @dc.to_hash(@rs).should == {:E => true}
+    end
+
+    it "with an integer value response" do
+      @a.update_attributes(:response_class => "integer")
+      @r.update_attributes(:integer_value => 10045)
+      @dc.integer_value = 10045
+      @dc.to_hash(@rs).should == {:E => false}
+      @r.update_attributes(:integer_value => 421)
+      @dc.to_hash(@rs).should == {:E => true}
+    end
+
+    it "with a float value response" do
+      @a.update_attributes(:response_class => "float")
+      @r.update_attributes(:float_value => 121.1)
+      @dc.float_value = 121.1
+      @dc.to_hash(@rs).should == {:E => false}
+      @r.update_attributes(:float_value => 130.123)
+      @dc.to_hash(@rs).should == {:E => true}
+    end
+  end
+
+  describe "evaluate the '<' operator" do
+    before(:each) do
+      @a = FactoryGirl.create(:answer)
+      @b = FactoryGirl.create(:answer, :question => @a.question)
+      @r = FactoryGirl.create(:response, :question => @a.question, :answer => @a)
+      @rs = @r.response_set
+      @dc = FactoryGirl.create(:dependency_condition, :question => @a.question, :answer => @a, :operator => "<", :rule_key => "F")
+      @dc.as(:answer).should == @r.as(:answer)
+    end
+
+    it "with an integer value response" do
+      @a.update_attributes(:response_class => "integer")
+      @r.update_attributes(:integer_value => 50)
+      @dc.integer_value = 100
+      @dc.to_hash(@rs).should == {:F => true}
+      @r.update_attributes(:integer_value => 421)
+      @dc.to_hash(@rs).should == {:F => false}
+    end
+
+    it "with a float value response" do
+      @a.update_attributes(:response_class => "float")
+      @r.update_attributes(:float_value => 5.1)
+      @dc.float_value = 121.1
+      @dc.to_hash(@rs).should == {:F => true}
+      @r.update_attributes(:float_value => 130.123)
+      @dc.to_hash(@rs).should == {:F => false}
+    end
+  end
+
+  describe "evaluate the '<=' operator" do
+    before(:each) do
+      @a = FactoryGirl.create(:answer)
+      @b = FactoryGirl.create(:answer, :question => @a.question)
+      @r = FactoryGirl.create(:response, :question => @a.question, :answer => @a)
+      @rs = @r.response_set
+      @dc = FactoryGirl.create(:dependency_condition, :question => @a.question, :answer => @a, :operator => "<=", :rule_key => "G")
+      @dc.as(:answer).should == @r.as(:answer)
+    end
+
+    it "with an integer value response" do
+      @a.update_attributes(:response_class => "integer")
+      @r.update_attributes(:integer_value => 50)
+      @dc.integer_value = 100
+      @dc.to_hash(@rs).should == {:G => true}
+      @r.update_attributes(:integer_value => 100)
+      @dc.to_hash(@rs).should == {:G => true}
+      @r.update_attributes(:integer_value => 421)
+      @dc.to_hash(@rs).should == {:G => false}
+    end
+
+    it "with a float value response" do
+      @a.update_attributes(:response_class => "float")
+      @r.update_attributes(:float_value => 5.1)
+      @dc.float_value = 121.1
+      @dc.to_hash(@rs).should == {:G => true}
+      @r.update_attributes(:float_value => 121.1)
+      @dc.to_hash(@rs).should == {:G => true}
+      @r.update_attributes(:float_value => 130.123)
+      @dc.to_hash(@rs).should == {:G => false}
+    end
+
+  end
+
+  describe "evaluate the '>' operator" do
+    before(:each) do
+      @a = FactoryGirl.create(:answer)
+      @b = FactoryGirl.create(:answer, :question => @a.question)
+      @r = FactoryGirl.create(:response, :question => @a.question, :answer => @a)
+      @rs = @r.response_set
+      @dc = FactoryGirl.create(:dependency_condition, :question => @a.question, :answer => @a, :operator => ">", :rule_key => "H")
+      @dc.as(:answer).should == @r.as(:answer)
+    end
+
+    it "with an integer value response" do
+      @a.update_attributes(:response_class => "integer")
+      @r.update_attributes(:integer_value => 50)
+      @dc.integer_value = 100
+      @dc.to_hash(@rs).should == {:H => false}
+      @r.update_attributes(:integer_value => 421)
+      @dc.to_hash(@rs).should == {:H => true}
+    end
+
+    it "with a float value response" do
+      @a.update_attributes(:response_class => "float")
+      @r.update_attributes(:float_value => 5.1)
+      @dc.float_value = 121.1
+      @dc.to_hash(@rs).should == {:H => false}
+      @r.update_attributes(:float_value => 130.123)
+      @dc.to_hash(@rs).should == {:H => true}
+    end
+  end
+
+  describe "evaluate the '>=' operator" do
+    before(:each) do
+      @a = FactoryGirl.create(:answer)
+      @b = FactoryGirl.create(:answer, :question => @a.question)
+      @r = FactoryGirl.create(:response, :question => @a.question, :answer => @a)
+      @rs = @r.response_set
+      @dc = FactoryGirl.create(:dependency_condition, :question => @a.question, :answer => @a, :operator => ">=", :rule_key => "I")
+      @dc.as(:answer).should == @r.as(:answer)
+    end
+
+    it "with an integer value response" do
+      @a.update_attributes(:response_class => "integer")
+      @r.update_attributes(:integer_value => 50)
+      @dc.integer_value = 100
+      @dc.to_hash(@rs).should == {:I => false}
+      @r.update_attributes(:integer_value => 100)
+      @dc.to_hash(@rs).should == {:I => true}
+      @r.update_attributes(:integer_value => 421)
+      @dc.to_hash(@rs).should == {:I => true}
+    end
+
+    it "with a float value response" do
+      @a.update_attributes(:response_class => "float")
+      @r.update_attributes(:float_value => 5.1)
+      @dc.float_value = 121.1
+      @dc.to_hash(@rs).should == {:I => false}
+      @r.update_attributes(:float_value => 121.1)
+      @dc.to_hash(@rs).should == {:I => true}
+      @r.update_attributes(:float_value => 130.123)
+      @dc.to_hash(@rs).should == {:I => true}
+    end
+  end
+
+  describe "evaluating with response_class string" do
+    it "should compare answer ids when the dependency condition string_value is nil" do
+      @a = FactoryGirl.create(:answer, :response_class => "string")
+      @b = FactoryGirl.create(:answer, :question => @a.question)
+      @r = FactoryGirl.create(:response, :question => @a.question, :answer => @a, :string_value => "")
+      @rs = @r.response_set
+      @dc = FactoryGirl.create(:dependency_condition, :question => @a.question, :answer => @a, :operator => "==", :rule_key => "J")
+      @dc.to_hash(@rs).should == {:J => true}
+    end
+
+    it "should compare strings when the dependency condition string_value is not nil, even if it is blank" do
+      @a = FactoryGirl.create(:answer, :response_class => "string")
+      @b = FactoryGirl.create(:answer, :question => @a.question)
+      @r = FactoryGirl.create(:response, :question => @a.question, :answer => @a, :string_value => "foo")
+      @rs = @r.response_set
+      @dc = FactoryGirl.create(:dependency_condition, :question => @a.question, :answer => @a, :operator => "==", :rule_key => "K", :string_value => "foo")
+      @dc.to_hash(@rs).should == {:K => true}
+
+      @r.update_attributes(:string_value => "")
+      @dc.string_value = ""
+      @dc.to_hash(@rs).should == {:K => true}
+    end
+  end
+
+  describe "evaluate 'count' operator" do
+    before(:each) do
+      @q = FactoryGirl.create(:question)
+      @dc = DependencyCondition.new(:operator => "count>2", :rule_key => "M", :question => @q)
+      @as = []
+      3.times do
+        @as << FactoryGirl.create(:answer, :question => @q, :response_class => "answer")
+      end
+      @rs = FactoryGirl.create(:response_set)
+      @as.slice(0,2).each do |a|
+        FactoryGirl.create(:response, :question => @q, :answer => a, :response_set => @rs)
+      end
+      @rs.save
+    end
+
+    it "with operator with >" do
+      @dc.to_hash(@rs).should == {:M => false}
+      FactoryGirl.create(:response, :question => @q, :answer => @as.last, :response_set => @rs)
+      @rs.reload.responses.count.should == 3
+      @dc.to_hash(@rs.reload).should == {:M => true}
+    end
+
+    it "with operator with <" do
+      @dc.operator = "count<2"
+      @dc.to_hash(@rs).should == {:M => false}
+      @dc.operator = "count<3"
+      @dc.to_hash(@rs).should == {:M => true}
+    end
+
+    it "with operator with <=" do
+      @dc.operator = "count<=1"
+      @dc.to_hash(@rs).should == {:M => false}
+      @dc.operator = "count<=2"
+      @dc.to_hash(@rs).should == {:M => true}
+      @dc.operator = "count<=3"
+      @dc.to_hash(@rs).should == {:M => true}
+    end
+
+    it "with operator with >=" do
+      @dc.operator = "count>=1"
+      @dc.to_hash(@rs).should == {:M => true}
+      @dc.operator = "count>=2"
+      @dc.to_hash(@rs).should == {:M => true}
+      @dc.operator = "count>=3"
+      @dc.to_hash(@rs).should == {:M => false}
+    end
+
+    it "with operator with !=" do
+      @dc.operator = "count!=1"
+      @dc.to_hash(@rs).should == {:M => true}
+      @dc.operator = "count!=2"
+      @dc.to_hash(@rs).should == {:M => false}
+      @dc.operator = "count!=3"
+      @dc.to_hash(@rs).should == {:M => true}
+    end
+  end
+
+end