hssc_surveyor 1.4.1.pre

data/lib/surveyor.rb

@@ -0,0 +1,13 @@
+module Surveyor
+  require 'surveyor/engine' if defined?(Rails) && Rails::VERSION::MAJOR == 3
+  autoload :VERSION, 'surveyor/version'
+  autoload :ParserError, 'surveyor/parser'
+end
+require 'surveyor/common'
+require 'surveyor/acts_as_response'
+# require 'surveyor/surveyor_controller_methods'
+# require 'surveyor/models/survey_methods'
+require 'formtastic'
+Formtastic::FormBuilder.default_text_area_height = 5
+Formtastic::FormBuilder.default_text_area_width = 50
+Formtastic::FormBuilder.all_fields_required_by_default = false

data/lib/tasks/surveyor_tasks.rake

@@ -0,0 +1,88 @@
+desc "generate and load survey (specify FILE=surveys/your_survey.rb)"
+task :surveyor => :"surveyor:parse"
+
+namespace :surveyor do
+  task :parse => :environment do
+    raise "USAGE: file name required e.g. 'FILE=surveys/kitchen_sink_survey.rb'" if ENV["FILE"].blank?
+    file = File.join(Rails.root, ENV["FILE"])
+    raise "File does not exist: #{file}" unless FileTest.exists?(file)
+    puts "--- Parsing #{file} ---"
+    Surveyor::Parser.parse_file(file, {:trace => Rake.application.options.trace})
+    puts "--- Done #{file} ---"
+  end
+  desc "generate and load survey from REDCap Data Dictionary (specify FILE=surveys/redcap.csv)"
+  task :redcap => :environment do
+    raise "USAGE: file name required e.g. 'FILE=surveys/redcap_demo_survey.csv'" if ENV["FILE"].blank?
+    file = File.join(Rails.root, ENV["FILE"])
+    raise "File does not exist: #{file}" unless FileTest.exists?(file)
+    puts "--- Parsing #{file} ---"
+    Surveyor::RedcapParser.parse File.read(file), File.basename(file, ".csv"), {:trace => Rake.application.options.trace}
+    puts "--- Done #{file} ---"
+  end
+  desc "generate a surveyor DSL file from a survey"
+  task :unparse => :environment do
+    surveys = Survey.all
+    if surveys
+      puts "The following surveys are available"
+      surveys.each do |survey|
+        puts "#{survey.id} #{survey.title}"
+      end
+      print "Which survey would you like to unparse? "
+      id = $stdin.gets.to_i
+      if survey_to_unparse = surveys.detect{|s| s.id == id}
+        filename = "surveys/#{survey_to_unparse.access_code}_#{Date.today.to_s(:db)}.rb"
+        puts "unparsing #{survey_to_unparse.title} to #{filename}"
+        File.open(filename, 'w') {|f| f.write(Surveyor::Unparser.unparse(survey_to_unparse))}
+      else
+        puts "not found"
+      end
+    else
+      puts "There are no surveys available"
+    end
+  end
+  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
+      print "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 without response sets"
+    end
+  end
+  desc "dump all responses to a given survey"
+  task :dump => :environment do
+    require 'fileutils.rb'
+    survey_version = ENV["SURVEY_VERSION"]
+    access_code = ENV["SURVEY_ACCESS_CODE"]
+
+    raise "USAGE: rake surveyor:dump SURVEY_ACCESS_CODE=<access_code> [OUTPUT_DIR=<dir>] [SURVEY_VERSION=<survey_version>]" unless access_code
+    params_string = "code #{access_code}"
+
+    surveys = Survey.where(:access_code => access_code).order("survey_version ASC")
+    if survey_version.blank?
+      survey = surveys.last
+    else
+      params_string += " and survey_version #{survey_version}"
+      survey = surveys.where(:survey_version => survey_version).first
+    end
+
+    raise "No Survey found with #{params_string}" unless survey
+    dir = ENV["OUTPUT_DIR"] || Rails.root
+    mkpath(dir) # Create all non-existent directories
+    full_path = File.join(dir,"#{survey.access_code}_v#{survey.survey_version}_#{Time.now.to_i}.csv")
+    File.open(full_path, 'w') do |f|
+      survey.response_sets.each_with_index{|r,i| f.write(r.to_csv(true, i == 0)) } # print access code every time, print_header first time
+    end
+  end
+end

data/rails/init.rb

@@ -0,0 +1 @@
+require 'surveyor'

data/spec/controllers/surveyor_controller_spec.rb

@@ -0,0 +1,307 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe SurveyorController do
+  include Surveyor::Engine.routes.url_helpers
+  before do
+    @routes = Surveyor::Engine.routes
+  end
+
+  let!(:survey)           { Factory(:survey, :title => "Alphabet", :access_code => "alpha", :survey_version => 0)}
+  let!(:survey_beta)      { Factory(:survey, :title => "Alphabet", :access_code => "alpha", :survey_version => 1)}
+  let!(:response_set)      { Factory(:response_set, :survey => survey, :access_code => "pdq")}
+  let!(:response_set_beta) { Factory(:response_set, :survey => survey_beta, :access_code => "rst")}
+  before { ResponseSet.stub!(:create).and_return(response_set) }
+
+  # match '/', :to                                     => 'surveyor#new', :as    => 'available_surveys', :via => :get
+  # match '/:survey_code', :to                         => 'surveyor#create', :as => 'take_survey', :via       => :post
+  # match '/:survey_code', :to                         => 'surveyor#export', :as => 'export_survey', :via     => :get
+  # match '/:survey_code/:response_set_code', :to      => 'surveyor#show', :as   => 'view_my_survey', :via    => :get
+  # match '/:survey_code/:response_set_code/take', :to => 'surveyor#edit', :as   => 'edit_my_survey', :via    => :get
+  # match '/:survey_code/:response_set_code', :to      => 'surveyor#update', :as => 'update_my_survey', :via  => :put
+
+  context "#new" do
+    def do_get
+      get :new
+    end
+    it "renders new" do
+      do_get
+      response.should be_success
+      response.should render_template('new')
+    end
+    it "assigns surveys_by_access_code" do
+      do_get
+      assigns(:surveys_by_access_code).should == {"alpha" => [survey_beta,survey]}
+    end
+  end
+
+  context "#create" do
+    def do_post(params = {})
+      post :create, {:survey_code => "alpha"}.merge(params)
+    end
+    it "finds latest version" do
+      do_post
+      assigns(:survey).should == survey_beta
+    end
+    it "finds specified survey_version" do
+      do_post :survey_version => 0
+      assigns(:survey).should == survey
+    end
+    it "creates a new response_set" do
+      ResponseSet.should_receive(:create)
+      do_post
+    end
+    it "should redirects to the new response_set" do
+      do_post
+      response.should redirect_to( edit_my_survey_path(:survey_code => "alpha", :response_set_code  => "pdq"))
+    end
+
+    context "with failures" do
+      it "redirect to #new on failed ResponseSet#create" do
+        ResponseSet.should_receive(:create).and_return(false)
+        do_post
+        response.should redirect_to(available_surveys_path)
+      end
+      it "redirect to #new on failed Survey#find" do
+        do_post :survey_code => "missing"
+        response.should redirect_to(available_surveys_path)
+      end
+    end
+
+    context "with javascript check, assigned in session" do
+      it "enabled" do
+        do_post :surveyor_javascript_enabled => "true"
+        session[:surveyor_javascript].should_not be_nil
+        session[:surveyor_javascript].should == "enabled"
+      end
+      it "disabled" do
+        post :create, :survey_code => "xyz", :surveyor_javascript_enabled => "not_true"
+        session[:surveyor_javascript].should_not be_nil
+        session[:surveyor_javascript].should == "not_enabled"
+      end
+    end
+  end
+
+  context "#show" do
+    def do_get(params = {})
+      get :show, {:survey_code => "alpha", :response_set_code => "pdq"}.merge(params)
+    end
+    it "renders show" do
+      do_get
+      response.should be_success
+      response.should render_template('show')
+    end
+    it "finds ResponseSet with includes" do
+      ResponseSet.should_receive(:find_by_access_code).with("pdq",{:include=>{:responses=>[:question, :answer]}})
+      do_get
+    end
+    it "redirects for missing response set" do
+      do_get :response_set_code => "DIFFERENT"
+      response.should redirect_to(available_surveys_path)
+    end
+    it "assigns earlier survey_version" do
+      response_set
+      do_get
+      assigns[:response_set].should == response_set
+      assigns[:survey].should == survey
+    end
+    it "assigns later survey_version" do
+      response_set_beta
+      do_get :response_set_code => "rst"
+      assigns[:response_set].should == response_set_beta
+      assigns[:survey].should == survey_beta
+    end
+  end
+
+  context "#edit" do
+    def do_get(params = {})
+      survey.sections = [Factory(:survey_section, :survey => survey)]
+      get :edit, {:survey_code => "alpha", :response_set_code => "pdq"}.merge(params)
+    end
+    it "renders edit" do
+      do_get
+      response.should be_success
+      response.should render_template('edit')
+    end
+    it "assigns survey and response set" do
+      do_get
+      assigns[:survey].should == survey
+      assigns[:response_set].should == response_set
+    end
+    it "redirects for missing response set" do
+      do_get :response_set_code => "DIFFERENT"
+      response.should redirect_to(available_surveys_path)
+    end
+    it "assigns dependents if javascript not enabled" do
+      controller.stub!(:get_unanswered_dependencies_minus_section_questions).and_return([Factory(:question)])
+      session[:surveyor_javascript].should be_nil
+      do_get
+      assigns[:dependents].should_not be_empty
+    end
+    it "does not assign dependents if javascript is enabled" do
+      controller.stub!(:get_unanswered_dependencies_minus_section_questions).and_return([Factory(:question)])
+      session[:surveyor_javascript] = "enabled"
+      do_get
+      assigns[:dependents].should be_empty
+    end
+    it "assigns earlier survey_version" do
+      do_get
+      assigns[:response_set].should == response_set
+      assigns[:survey].should == survey
+    end
+    it "assigns later survey_version" do
+      survey_beta.sections = [Factory(:survey_section, :survey => survey_beta)]
+      do_get :response_set_code => "rst"
+      assigns[:survey].should == survey_beta
+      assigns[:response_set].should == response_set_beta
+
+    end
+  end
+
+  context "#update" do
+    let(:responses_ui_hash) { {} }
+    let(:update_params) {
+      {
+        :survey_code => "alpha",
+        :response_set_code => "pdq"
+      }
+    }
+    shared_examples "#update action" do
+      before do
+        ResponseSet.stub!(:find_by_access_code).and_return(response_set)
+        responses_ui_hash['11'] = {'api_id' => 'something', 'answer_id' => '56', 'question_id' => '9'}
+      end
+      it "finds a response set" do
+        ResponseSet.should_receive(:find_by_access_code).and_return(response_set)
+        do_put
+      end
+      it "saves responses" do
+        response_set.should_receive(:update_from_ui_hash).with(responses_ui_hash)
+
+        do_put(:r => responses_ui_hash)
+      end
+      it "does not fail when there are no responses" do
+        lambda { do_put }.should_not raise_error
+      end
+      context "with update exceptions" do
+        it 'retries the update on a constraint violation' do
+          response_set.should_receive(:update_from_ui_hash).ordered.with(responses_ui_hash).and_raise(ActiveRecord::StatementInvalid)
+          response_set.should_receive(:update_from_ui_hash).ordered.with(responses_ui_hash)
+
+          expect { do_put(:r => responses_ui_hash) }.to_not raise_error
+        end
+
+        it 'only retries three times' do
+          response_set.should_receive(:update_from_ui_hash).exactly(3).times.with(responses_ui_hash).and_raise(ActiveRecord::StatementInvalid)
+
+          expect { do_put(:r => responses_ui_hash) }.to raise_error(ActiveRecord::StatementInvalid)
+        end
+
+        it 'does not retry for other errors' do
+          response_set.should_receive(:update_from_ui_hash).once.with(responses_ui_hash).and_raise('Bad news')
+
+          expect { do_put(:r => responses_ui_hash) }.to raise_error('Bad news')
+        end
+      end
+    end
+
+    context "with form submission" do
+      def do_put(extra_params = {})
+        put :update, update_params.merge(extra_params)
+      end
+
+      it_behaves_like "#update action"
+      it "redirects to #edit without params" do
+        do_put
+        response.should redirect_to(edit_my_survey_path(:survey_code => "alpha", :response_set_code => "pdq"))
+      end
+      it "completes the found response set on finish" do
+        do_put :finish => 'finish'
+        response_set.reload.should be_complete
+      end
+      it 'flashes completion' do
+        do_put :finish => 'finish'
+        flash[:notice].should == "Completed survey"
+      end
+      it "redirects for missing response set" do
+        do_put :response_set_code => "DIFFERENT"
+        response.should redirect_to(available_surveys_path)
+        flash[:notice].should == "Unable to find your responses to the survey"
+      end
+    end
+
+    context 'with ajax' do
+      def do_put(extra_params = {})
+        xhr :put, :update, update_params.merge(extra_params)
+      end
+
+      it_behaves_like "#update action"
+      it "returns dependencies" do
+        ResponseSet.stub!(:find_by_access_code).and_return(response_set)
+        response_set.should_receive(:all_dependencies).and_return({"show" => ['q_1'], "hide" => ['q_2']})
+
+        do_put
+        JSON.parse(response.body).should == {"show" => ['q_1'], "hide" => ["q_2"]}
+      end
+      it "returns 404 for missing response set" do
+        do_put :response_set_code => "DIFFERENT"
+        response.status.should == 404
+      end
+    end
+  end
+
+  context "#export" do
+    render_views
+
+    let(:json) {
+      get :export, :survey_code => survey.access_code, :format => 'json'
+      JSON.parse(response.body)
+    }
+
+    context "question inside and outside a question group" do
+      def question_text(refid)
+        <<-SURVEY
+          q "Where is a foo?", :pick => :one, :help_text => 'Look around.', :reference_identifier => #{refid.inspect},
+            :data_export_identifier => 'X.FOO', :common_namespace => 'F', :common_identifier => 'f'
+          a_L 'To the left', :data_export_identifier => 'X.L', :common_namespace => 'F', :common_identifier => 'l'
+          a_R 'To the right', :data_export_identifier => 'X.R', :common_namespace => 'F', :common_identifier => 'r'
+          a_O 'Elsewhere', :string
+
+          dependency :rule => 'R'
+          condition_R :q_bar, "==", :a_1
+        SURVEY
+      end
+      let(:survey_text) {
+        <<-SURVEY
+          survey 'xyz' do
+            section 'Sole' do
+              q_bar "Should that other question show up?", :pick => :one
+              a_1 'Yes'
+              a_2 'No'
+
+              #{question_text('foo_solo')}
+
+              group do
+                #{question_text('foo_grouped')}
+              end
+            end
+          end
+        SURVEY
+      }
+      let(:survey) { Surveyor::Parser.new.parse(survey_text) }
+      let(:solo_question_json)    { json['sections'][0]['questions_and_groups'][1] }
+      let(:grouped_question_json) { json['sections'][0]['questions_and_groups'][2]['questions'][0] }
+
+      it "produces identical JSON except for API IDs and question reference identifers" do
+        solo_question_json['answers'].to_json.should be_json_eql( grouped_question_json['answers'].to_json).excluding("uuid", "reference_identifier")
+        solo_question_json['dependency'].to_json.should be_json_eql( grouped_question_json['dependency'].to_json).excluding("uuid", "reference_identifier")
+        solo_question_json.to_json.should be_json_eql( grouped_question_json.to_json).excluding("uuid", "reference_identifier")
+      end
+      it "produces the expected reference identifier for the solo question" do
+        solo_question_json['reference_identifier'].should == 'foo_solo'
+      end
+      it "produces the expected reference identifer for the question in the group" do
+        grouped_question_json['reference_identifier'].should == 'foo_grouped'
+      end
+    end
+  end
+end

data/spec/factories.rb

@@ -0,0 +1,161 @@
+# encoding: utf-8
+# http://github.com/thoughtbot/factory_girl/tree/master
+require 'rubygems'
+require 'factory_girl'
+
+Factory.sequence(:unique_survey_access_code){|n| "simple survey #{UUIDTools::UUID.random_create.to_s}" }
+
+Factory.define :survey do |s|
+  s.title           "Simple survey"
+  s.description     "A simple survey for testing"
+  s.access_code     { Factory.next :unique_survey_access_code }
+  s.survey_version  0
+end
+
+Factory.define :survey_translation do |t|
+  t.locale "es"
+  t.translation %(title: "Un idioma nunca es suficiente"
+survey_sections:
+  one:
+    title: "Uno"
+questions:
+  hello:
+    text: "¡Hola!"
+  name:
+    text: "¿Cómo se llama Usted?"
+    answers:
+      name:
+        help_text: "Mi nombre es...")
+end
+
+Factory.sequence(:survey_section_display_order){|n| n }
+
+Factory.define :survey_section do |s|
+  s.association               :survey # s.survey_id                 {}
+  s.title                     {"Demographics"}
+  s.description               {"Asking you about your personal data"}
+  s.display_order             {Factory.next :survey_section_display_order}
+  s.reference_identifier      {"demographics"}
+  s.data_export_identifier    {"demographics"}
+end
+
+Factory.sequence(:question_display_order){|n| n }
+
+Factory.define :question do |q|
+  q.association             :survey_section  # s.survey_section_id       {}
+  # q.question_group_id       {}
+  q.text                    "What is your favorite color?"
+  q.short_text              "favorite_color"
+  q.help_text               "just write it in the box"
+  q.pick                    :none
+  q.reference_identifier    {|me| "q_#{me.object_id}"}
+  # q.data_export_identifier  {}
+  # q.common_namespace        {}
+  # q.common_identifier       {}
+  q.display_order           Factory.next :question_display_order
+  # q.display_type            {} # nil is default
+  q.is_mandatory            false
+  # q.display_width           {}
+  q.correct_answer_id       nil
+end
+
+Factory.define :question_group do |g|
+  g.text                    {"Describe your family"}
+  g.help_text               {}
+  g.reference_identifier    {|me| "g_#{me.object_id}"}
+  g.data_export_identifier  {}
+  g.common_namespace        {}
+  g.common_identifier       {}
+  g.display_type            {}
+  g.custom_class            {}
+  g.custom_renderer         {}
+end
+
+Factory.sequence(:answer_display_order){|n| n }
+
+Factory.define :answer do |a|
+  a.association               :question  # a.question_id               {}
+  a.text                      "My favorite color is clear"
+  a.short_text                "clear"
+  a.help_text                 "Clear is the absense of color"
+  # a.weight
+  a.response_class            "string"
+  # a.reference_identifier      {}
+  # a.data_export_identifier    {}
+  # a.common_namespace          {}
+  # a.common_identifier         {}
+  a.display_order             {Factory.next :answer_display_order}
+  # a.is_exclusive              {}
+  a.display_type              "default"
+  # a.display_length            {}
+  # a.custom_class              {}
+  # a.custom_renderer           {}
+end
+
+Factory.define :dependency do |d|
+  # the dependent question
+  d.association       :question # d.question_id       {}
+  d.question_group_id {}
+  d.rule              {"A"}
+end
+
+Factory.define :dependency_condition do |d|
+  d.association       :dependency # d.dependency_id    {}
+  d.rule_key          {"A"}
+  # the conditional question
+  d.question_id       {}
+  d.operator          {"=="}
+  d.answer_id         {}
+  d.datetime_value    {}
+  d.integer_value     {}
+  d.float_value       {}
+  d.unit              {}
+  d.text_value        {}
+  d.string_value      {}
+  d.response_other    {}
+end
+
+Factory.define :response_set do |r|
+  r.user_id         {}
+  r.association     :survey # r.survey_id       {}
+  r.access_code     {Surveyor::Common.make_tiny_code}
+  r.started_at      {Time.now}
+  r.completed_at    {}
+end
+
+Factory.define :response do |r|
+  r.association       :response_set # r.response_set_id   {}
+  r.survey_section_id {}
+  r.question_id       {}
+  r.answer_id         {}
+  r.datetime_value    {}
+  r.integer_value     {}
+  r.float_value       {}
+  r.unit              {}
+  r.text_value        {}
+  r.string_value      {}
+  r.response_other    {}
+  r.response_group    {}
+end
+
+Factory.define :validation do |v|
+  v.association       :answer # v.answer_id         {}
+  v.rule              {"A"}
+  v.message           {}
+end
+
+Factory.define :validation_condition do |v|
+  v.association       :validation # v.validation_id     {}
+  v.rule_key          {"A"}
+  v.question_id       {}
+  v.operator          {"=="}
+  v.answer_id         {}
+  v.datetime_value    {}
+  v.integer_value     {}
+  v.float_value       {}
+  v.unit              {}
+  v.text_value        {}
+  v.string_value      {}
+  v.response_other    {}
+  v.regexp            {}
+end

data/spec/helpers/formtastic_custom_input_spec.rb

@@ -0,0 +1,15 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+require File.expand_path(File.dirname(__FILE__) + '/../../lib/surveyor/helpers/formtastic_custom_input')
+
+describe Surveyor::Helpers::FormtasticCustomInput do
+  context "input helpers" do
+    it "should translate response class into attribute" do
+      helper.response_class_to_method(:string).should == :string_value
+      helper.response_class_to_method(:integer).should == :integer_value
+      helper.response_class_to_method(:float).should == :float_value
+      helper.response_class_to_method(:datetime).should == :datetime_value
+      helper.response_class_to_method(:date).should == :date_value
+      helper.response_class_to_method(:time).should == :time_value
+    end
+  end
+end