surveyor 0.22.0 → 1.0.0

data/lib/surveyor/redcap_parser.rb

@@ -3,42 +3,51 @@ require 'active_support' # for humanize
 require 'fastercsv'
 require 'csv'
 module Surveyor
+  class RedcapParserError < StandardError; end
   class RedcapParser
+    class << self; attr_accessor :options end
+
     # Attributes
     attr_accessor :context
 
     # Class methods
-    def self.parse(str, filename)
-      puts
+    def self.parse(str, filename, options={})
+      self.options = options
+      Surveyor::RedcapParser.rake_trace "\n"
       Surveyor::RedcapParser.new.parse(str, filename)
-      puts
-      puts
+      Surveyor::RedcapParser.rake_trace "\n"
+    end
+    def self.rake_trace(str)
+      self.options ||= {}
+      print str if self.options[:trace] == true
     end
-    
+
     # Instance methods
     def initialize
       self.context = {}
+      self.context[:dependency_conditions] = []
     end
     def parse(str, filename)
       csvlib = CSV.const_defined?(:Reader) ? FasterCSV : CSV
       begin
         csvlib.parse(str, :headers => :first_row, :return_headers => true, :header_converters => :symbol) do |r|
           if r.header_row? # header row
-            return puts "Missing headers: #{missing_columns(r.headers).inspect}\n\n" unless missing_columns(r.headers).blank?
+            return Surveyor::RedcapParser.rake_trace "Missing headers: #{missing_columns(r.headers).inspect}\n\n" unless missing_columns(r.headers).blank?
             context[:survey] = Survey.new(:title => filename)
-            print "survey_#{context[:survey].access_code} "
+            Surveyor::RedcapParser.rake_trace "survey_#{context[:survey].access_code} "
           else # non-header rows
-            SurveySection.build_or_set(context, r)
-            Question.build_and_set(context, r)
-            Answer.build_and_set(context, r)
-            Validation.build_and_set(context, r)
-            Dependency.build_and_set(context, r)
+            SurveySection.new.extend(SurveyorRedcapParserSurveySectionMethods).build_or_set(context, r)
+            Question.new.extend(SurveyorRedcapParserQuestionMethods).build_and_set(context, r)
+            Answer.new.extend(SurveyorRedcapParserAnswerMethods).build_and_set(context, r)
+            Validation.new.extend(SurveyorRedcapParserValidationMethods).build_and_set(context, r)
+            Dependency.new.extend(SurveyorRedcapParserDependencyMethods).build_and_set(context, r)
           end
         end
-        print context[:survey].save ? "saved. " : " not saved! #{context[:survey].errors.full_messages.join(", ")} "
-        # print context[:survey].sections.map(&:questions).flatten.map(&:answers).flatten.map{|x| x.errors.each_full{|y| y}.join}.join
+        resolve_references
+        Surveyor::RedcapParser.rake_trace context[:survey].save ? "saved. " : " not saved! #{context[:survey].errors.full_messages.join(", ")} "
+        # Surveyor::RedcapParser.rake_trace context[:survey].sections.map(&:questions).flatten.map(&:answers).flatten.map{|x| x.errors.each_full{|y| y}.join}.join
       rescue csvlib::MalformedCSVError
-        puts = "Oops. Not a valid CSV file."
+        raise Surveyor::RedcapParserError, "Oops. Not a valid CSV file."
       # ensure
       end
       return context[:survey]
@@ -46,42 +55,61 @@ module Surveyor
     def missing_columns(r)
       missing = []
       missing << "choices_or_calculations" unless r.map(&:to_s).include?("choices_or_calculations") or r.map(&:to_s).include?("choices_calculations_or_slider_labels")
-      missing << "text_validation_type" unless r.map(&:to_s).include?("text_validation_type") or r.map(&:to_s).include?("text_validation_type_or_show_slider_number") 
+      missing << "text_validation_type" unless r.map(&:to_s).include?("text_validation_type") or r.map(&:to_s).include?("text_validation_type_or_show_slider_number")
       missing += (static_required_columns - r.map(&:to_s))
     end
     def static_required_columns
       # no longer requiring field_units
       %w(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)
     end
+    def resolve_references
+      context[:dependency_conditions].each do |dc|
+        return unless dc.lookup_reference
+        Surveyor::RedcapParser.rake_trace "resolve(#{dc.question_reference},#{dc.answer_reference})"
+        if dc.answer_reference.blank? and (row = dc.lookup_reference.find{|r| r[0] == dc.question_reference and r[1] == nil}) and row[2].answers.size == 1
+          Surveyor::RedcapParser.rake_trace "...found "
+          dc.question = row[2]
+          dc.answer = dc.question.answers.first
+        elsif row = dc.lookup_reference.find{|r| r[0] == dc.question_reference and r[1] == dc.answer_reference}
+          Surveyor::RedcapParser.rake_trace "...found "
+          dc.answer = row[2]
+          dc.question = dc.answer.question
+        else
+          Surveyor::RedcapParser.rake_trace "\n!!! failed lookup for dependency_condition q: #{question_reference} a: #{question_reference}"
+        end
+      end
+    end
   end
 end
 
 # Surveyor models with extra parsing methods
-class Survey < ActiveRecord::Base
-end
-class SurveySection < ActiveRecord::Base
-  def self.build_or_set(context, r)
+
+# SurveySection model
+module SurveyorRedcapParserSurveySectionMethods
+  def build_or_set(context, r)
     unless context[:survey_section] && context[:survey_section].reference_identifier == r[:form_name]
       if match = context[:survey].sections.detect{|ss| ss.reference_identifier == r[:form_name]}
         context[:current_survey_section] = match
       else
-        context[:survey_section] = context[:survey].sections.build({:title => r[:form_name].to_s.humanize, 
-                                                                    :reference_identifier => r[:form_name],
-                                                                    :display_order => context[:survey].sections.size })
-        print "survey_section_#{context[:survey_section].reference_identifier} "
+        self.attributes = (
+          {:title => r[:form_name].to_s.humanize,
+          :reference_identifier => r[:form_name],
+          :display_order => context[:survey].sections.size })
+        context[:survey].sections << context[:survey_section] = self
+        Surveyor::RedcapParser.rake_trace "survey_section_#{context[:survey_section].reference_identifier} "
       end
     end
   end
 end
-class QuestionGroup < ActiveRecord::Base
-end
-class Question < ActiveRecord::Base
-  def self.build_and_set(context, r)
+
+# Question model
+module SurveyorRedcapParserQuestionMethods
+  def build_and_set(context, r)
     if !r[:section_header].blank?
       context[:survey_section].questions.build({:display_type => "label", :text => r[:section_header], :display_order => context[:survey_section].questions.size})
-      print "label_ "
+      Surveyor::RedcapParser.rake_trace "label_ "
     end
-    context[:question] = context[:survey_section].questions.build({
+    self.attributes = ({
       :reference_identifier => r[:variable__field_name],
       :text => r[:field_label],
       :help_text => r[:field_note],
@@ -90,33 +118,38 @@ class Question < ActiveRecord::Base
       :display_type => display_type_from_field_type(r[:field_type]),
       :display_order => context[:survey_section].questions.size
     })
+    context[:survey_section].questions << context[:question] = self
     unless context[:question].reference_identifier.blank?
       context[:lookup] ||= []
       context[:lookup] << [context[:question].reference_identifier, nil, context[:question]]
-    end    
-    print "question_#{context[:question].reference_identifier} "
+    end
+    Surveyor::RedcapParser.rake_trace "question_#{context[:question].reference_identifier} "
   end
-  def self.pick_from_field_type(ft)
+  def pick_from_field_type(ft)
     {"checkbox" => :any, "radio" => :one}[ft] || :none
   end
-  def self.display_type_from_field_type(ft)
+  def display_type_from_field_type(ft)
     {"text" => :string, "dropdown" => :dropdown, "notes" => :text}[ft]
   end
 end
-class Dependency < ActiveRecord::Base
-  def self.build_and_set(context, r)
+
+# Dependency model
+module SurveyorRedcapParserDependencyMethods
+  def build_and_set(context, r)
     unless (bl = r[:branching_logic_show_field_only_if]).blank?
       # TODO: forgot to tie rule key to component, counting on the sequence of components
       letters = ('A'..'Z').to_a
       hash = decompose_rule(bl)
-      context[:dependency] = context[:question].build_dependency(:rule => hash[:rule])
+      self.attributes = {:rule => hash[:rule]}
+      context[:question].dependency = context[:dependency] = self
       hash[:components].each do |component|
-        context[:dependency].dependency_conditions.build(decompose_component(component).merge(:lookup_reference => context[:lookup], :rule_key => letters.shift))
+        dc = context[:dependency].dependency_conditions.build(decompose_component(component).merge(:lookup_reference => context[:lookup], :rule_key => letters.shift))
+        context[:dependency_conditions] << dc
       end
-      print "dependency(#{hash[:rule]}) "
+      Surveyor::RedcapParser.rake_trace "dependency(#{hash[:rule]}) "
     end
   end
-  def self.decompose_component(str)
+  def decompose_component(str)
     # [initial_52] = "1" or [f1_q15] = '' or [f1_q15] = '-2' or [hi_event1_type] <> ''
     if match = str.match(/^\[(\w+)\] ?([!=><]+) ?['"](-?\w*)['"]$/)
       {:question_reference => match[1], :operator => match[2].gsub(/^=$/, "==").gsub(/^<>$/, "!="), :answer_reference => match[3]}
@@ -127,10 +160,10 @@ class Dependency < ActiveRecord::Base
     elsif match = str.match(/^\[(\w+)\] ?([!=><]+) ?(-?\d+)$/)
       {:question_reference => match[1], :operator => match[2].gsub(/^=$/, "==").gsub(/^<>$/, "!="), :integer_value => match[3]}
     else
-      puts "\n!!! skipping dependency_condition #{str}"
-    end    
+      Surveyor::RedcapParser.rake_trace "\n!!! skipping dependency_condition #{str}"
+    end
   end
-  def self.decompose_rule(str)
+  def decompose_rule(str)
     # see spec/lib/redcap_parser_spec.rb for examples
     letters = ('A'..'Z').to_a
     rule = str
@@ -149,7 +182,7 @@ class Dependency < ActiveRecord::Base
         # sub in rule key
         rule = rule.gsub(part, "(#{nums.map{letters.shift}.join(' and ')})")
       else
-        # 'or' on the right of the operator        
+        # 'or' on the right of the operator
         components[i] = components[i-1].gsub(/"(\d+)"/, part) if part.match(/^"(\d+)"$/) && i != 0
         # sub in rule key
         rule = rule.gsub(part){letters.shift}
@@ -158,60 +191,66 @@ class Dependency < ActiveRecord::Base
     {:rule => rule, :components => components.flatten}
   end
 end
-class DependencyCondition < ActiveRecord::Base
-  attr_accessor :question_reference, :answer_reference, :lookup_reference
-  before_save :resolve_references
-  def resolve_references
-    return unless lookup_reference
-    print "resolve(#{question_reference},#{answer_reference})"
-    if answer_reference.blank? and (row = lookup_reference.find{|r| r[0] == question_reference and r[1] == nil}) and row[2].answers.size == 1
-      print "...found "
-      self.question = row[2]
-      self.answer = self.question.answers.first
-    elsif row = lookup_reference.find{|r| r[0] == question_reference and r[1] == answer_reference}    
-      print "...found "
-      self.answer = row[2]
-      self.question = self.answer.question
-    else
-      puts "\n!!! failed lookup for dependency_condition q: #{question_reference} a: #{question_reference}"
-    end
+
+# DependencyCondition model
+module SurveyorRedcapParserDependencyConditionMethods
+  DependencyCondition.instance_eval do
+    attr_accessor :question_reference, :answer_reference, :lookup_reference
+    attr_accessible :question_reference, :answer_reference, :lookup_reference
   end
 end
-class Answer < ActiveRecord::Base
-  def self.build_and_set(context, r)
+
+# Answer model
+module SurveyorRedcapParserAnswerMethods
+  def build_and_set(context, r)
     case r[:field_type]
     when "text"
-      context[:answer] = context[:question].answers.build(:response_class => "string", :text => "Text", :display_order => context[:question].answers.size)
+      self.attributes = {
+        :response_class => "string",
+        :text => "Text",
+        :display_order => context[:question].answers.size }
+      context[:question].answers << context[:answer] = self
     when "notes"
-      context[:answer] = context[:question].answers.build(:response_class => "text", :text => "Notes", :display_order => context[:question].answers.size)
+      self.attributes = {
+        :response_class => "text",
+        :text => "Notes",
+        :display_order => context[:question].answers.size }
+      context[:question].answers << context[:answer] = self
     when "file"
-      puts "\n!!! skipping answer: file"
+      Surveyor::RedcapParser.rake_trace "\n!!! skipping answer: file"
     end
     (r[:choices_or_calculations] || r[:choices_calculations_or_slider_labels]).to_s.split("|").each do |pair|
       aref, atext = pair.split(",").map(&:strip)
       if aref.blank? or atext.blank? or (aref.to_i.to_s != aref)
-        puts "\n!!! skipping answer #{pair}"
+        Surveyor::RedcapParser.rake_trace "\n!!! skipping answer #{pair}"
       else
-        context[:answer] = context[:question].answers.build(:reference_identifier => aref, :text => atext, :display_order => context[:question].answers.size)
+        a = Answer.new({
+          :reference_identifier => aref,
+          :text => atext,
+          :display_order => context[:question].answers.size })
+        context[:question].answers << context[:answer] = a
         unless context[:question].reference_identifier.blank? or aref.blank? or !context[:answer].valid?
           context[:lookup] ||= []
           context[:lookup] << [context[:question].reference_identifier, aref, context[:answer]]
         end
-        puts "#{context[:answer].errors.full_messages}, #{context[:answer].inspect}" unless context[:answer].valid?
-        print "answer_#{context[:answer].reference_identifier} "
+        Surveyor::RedcapParser.rake_trace "#{context[:answer].errors.full_messages}, #{context[:answer].inspect}" unless context[:answer].valid?
+        Surveyor::RedcapParser.rake_trace "answer_#{context[:answer].reference_identifier} "
       end
     end
   end
 end
-class Validation < ActiveRecord::Base
-  def self.build_and_set(context, r)
+
+# Validation model
+module SurveyorRedcapParserValidationMethods
+  def build_and_set(context, r)
     # text_validation_type text_validation_min text_validation_max
     min = r[:text_validation_min].to_s.blank? ? nil : r[:text_validation_min].to_s
     max = r[:text_validation_max].to_s.blank? ? nil : r[:text_validation_max].to_s
     type = r[:text_validation_type].to_s.blank? ? nil : r[:text_validation_type].to_s
     if min or max
       context[:question].answers.each do |a|
-        context[:validation] = a.validations.build(:rule => min ? max ? "A and B" : "A" : "B")
+        self.rule = (min ? max ? "A and B" : "A" : "B")
+        a.validations << context[:validation] = self
         context[:validation].validation_conditions.build(:rule_key => "A", :operator => ">=", :integer_value => min) if min
         context[:validation].validation_conditions.build(:rule_key => "B", :operator => "<=", :integer_value => max) if max
       end
@@ -222,30 +261,31 @@ class Validation < ActiveRecord::Base
         context[:question].display_type = :date if context[:question].display_type == :string
       when "email"
         context[:question].answers.each do |a|
-          context[:validation] = a.validations.build(:rule => "A")
+          self.rule = "A"
+          a.validations << context[:validation] = self
           context[:validation].validation_conditions.build(:rule_key => "A", :operator => "=~", :regexp => "^[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,4}$")
         end
       when "integer"
         context[:question].display_type = :integer if context[:question].display_type == :string
         context[:question].answers.each do |a|
-          context[:validation] = a.validations.build(:rule => "A")
+          self.rule = "A"
+          a.validations << context[:validation] = self
           context[:validation].validation_conditions.build(:rule_key => "A", :operator => "=~", :regexp => "\d+")
         end
       when "number"
         context[:question].display_type = :float if context[:question].display_type == :string
         context[:question].answers.each do |a|
-          context[:validation] = a.validations.build(:rule => "A")
+          self.rule = "A"
+          a.validations << context[:validation] = self
           context[:validation].validation_conditions.build(:rule_key => "A", :operator => "=~", :regexp => "^\d*(,\d{3})*(\.\d*)?$")
         end
       when "phone"
         context[:question].answers.each do |a|
-          context[:validation] = a.validations.build(:rule => "A")
+                    self.rule = "A"
+          a.validations << context[:validation] = self
           context[:validation].validation_conditions.build(:rule_key => "A", :operator => "=~", :regexp => "\d{3}.*\d{4}")
         end
       end
     end
   end
-  
-end
-class ValidationCondition < ActiveRecord::Base
 end

data/lib/surveyor/surveyor_controller_methods.rb

@@ -1,43 +1,58 @@
 require 'rabl'
 Rabl.register!
+Rabl.configure {|config| config.include_child_root = false }
 Rabl.configure {|config| config.include_json_root = false }
 module Surveyor
   module SurveyorControllerMethods
     def self.included(base)
       base.send :before_filter, :get_current_user, :only => [:new, :create]
       base.send :before_filter, :determine_if_javascript_is_enabled, :only => [:create, :update]
-      base.send :before_filter, :set_render_context, :only => [:edit]
+      base.send :before_filter, :set_response_set_and_render_context, :only => [:edit, :show]
       base.send :layout, 'surveyor_default'
     end
 
     # Actions
     def new
       @surveys = Survey.find(:all)
+      @codes = @surveys.inject({}) do |codes,s|
+        codes[s.access_code] ||= {}
+        codes[s.access_code][:title] = s.title
+        codes[s.access_code][:survey_versions] ||= []
+        codes[s.access_code][:survey_versions] << s.survey_version
+        codes
+      end
       @title = "You can take these surveys"
       redirect_to surveyor_index unless surveyor_index == available_surveys_path
     end
 
     def create
-      @survey = Survey.find_by_access_code(params[:survey_code])
-      @response_set = ResponseSet.create(:survey => @survey, :user_id => (@current_user.nil? ? @current_user : @current_user.id))
+      surveys = Survey.where(:access_code => params[:survey_code]).order("survey_version DESC")
+      if params[:survey_version].blank?
+        @survey = surveys.first
+      else
+        @survey = surveys.where(:survey_version => params[:survey_version]).first
+      end
+      @response_set = ResponseSet.
+        create(:survey => @survey, :user_id => (@current_user.nil? ? @current_user : @current_user.id))
       if (@survey && @response_set)
         flash[:notice] = t('surveyor.survey_started_success')
-        redirect_to(edit_my_survey_path(:survey_code => @survey.access_code, :response_set_code  => @response_set.access_code))
+        redirect_to(edit_my_survey_path(
+          :survey_code => @survey.access_code, :response_set_code  => @response_set.access_code))
       else
         flash[:notice] = t('surveyor.Unable_to_find_that_survey')
         redirect_to surveyor_index
       end
     end
 
-
     def show
-      @response_set = ResponseSet.find_by_access_code(params[:response_set_code], :include => {:responses => [:question, :answer]})
+      # @response_set is set in before_filter - set_response_set_and_render_context
       if @response_set
         @survey = @response_set.survey
         respond_to do |format|
           format.html #{render :action => :show}
           format.csv {
-            send_data(@response_set.to_csv, :type => 'text/csv; charset=utf-8; header=present',:filename => "#{@response_set.updated_at.strftime('%Y-%m-%d')}_#{@response_set.access_code}.csv")
+            send_data(@response_set.to_csv, :type => 'text/csv; charset=utf-8; header=present',
+              :filename => "#{@response_set.updated_at.strftime('%Y-%m-%d')}_#{@response_set.access_code}.csv")
           }
           format.json
         end
@@ -48,7 +63,7 @@ module Surveyor
     end
 
     def edit
-      @response_set = ResponseSet.find_by_access_code(params[:response_set_code], :include => {:responses => [:question, :answer]})
+      # @response_set is set in before_filter - set_response_set_and_render_context
       if @response_set
         @survey = Survey.with_sections.find_by_id(@response_set.survey_id)
         @sections = @survey.sections
@@ -65,45 +80,76 @@ module Surveyor
     end
 
     def update
-      saved = false
-      ActiveRecord::Base.transaction do
-        @response_set = ResponseSet.find_by_access_code(params[:response_set_code], :include => {:responses => :answer}, :lock => true)
-        unless @response_set.blank?
-          saved = @response_set.update_attributes(:responses_attributes => ResponseSet.to_savable(params[:r]))
-          @response_set.complete! if saved && params[:finish]
-          saved &= @response_set.save
-        end
-      end
+      saved = load_and_update_response_set_with_retries
+
       return redirect_with_message(surveyor_finish, :notice, t('surveyor.completed_survey')) if saved && params[:finish]
 
       respond_to do |format|
         format.html do
-          if @response_set.blank?
+          if @response_set.nil?
             return redirect_with_message(available_surveys_path, :notice, t('surveyor.unable_to_find_your_responses'))
           else
             flash[:notice] = t('surveyor.unable_to_update_survey') unless saved
-            redirect_to edit_my_survey_path(:anchor => anchor_from(params[:section]), :section => section_id_from(params[:section]))
+            redirect_to edit_my_survey_path(
+              :anchor => anchor_from(params[:section]), :section => section_id_from(params[:section]))
           end
         end
         format.js do
-          ids, remove, question_ids = {}, {}, []
-          ResponseSet.trim_for_lookups(params[:r]).each do |k,v|
-            v[:answer_id].reject!(&:blank?) if v[:answer_id].is_a?(Array)
-            ids[k] = @response_set.responses.find(:first, :conditions => v, :order => "created_at DESC").id if !v.has_key?("id")
-            remove[k] = v["id"] if v.has_key?("id") && v.has_key?("_destroy")
-            question_ids << v["question_id"]
+          if @response_set
+            render :json => @response_set.reload.all_dependencies
+          else
+            render :text => "No response set #{params[:response_set_code]}",
+              :status => 404
+          end
+        end
+      end
+    end
+
+    def load_and_update_response_set_with_retries(remaining=2)
+      begin
+        load_and_update_response_set
+      rescue ActiveRecord::StatementInvalid => e
+        if remaining > 0
+          load_and_update_response_set_with_retries(remaining - 1)
+        else
+          raise e
+        end
+      end
+    end
+
+    def load_and_update_response_set
+      ResponseSet.transaction do
+        @response_set = ResponseSet.
+          find_by_access_code(params[:response_set_code], :include => {:responses => :answer})
+        if @response_set
+          saved = true
+          if params[:r]
+            @response_set.update_from_ui_hash(params[:r])
           end
-          render :json => {"ids" => ids, "remove" => remove}.merge(@response_set.reload.all_dependencies(question_ids))
+          if params[:finish]
+            @response_set.complete!
+            saved &= @response_set.save
+          end
+          saved
+        else
+          false
         end
       end
     end
-    
+    private :load_and_update_response_set
+
     def export
-      @survey = Survey.find_by_access_code(params[:survey_code])
+      surveys = Survey.where(:access_code => params[:survey_code]).order("survey_version DESC")
+      if params[:survey_version].blank?
+        @survey = surveys.first
+      else
+        @survey = surveys.where(:survey_version => params[:survey_version]).first
+      end
     end
+
     private
 
-    # This is a hoock method for surveyor-using applications to override and provide the context object
+    # This is a hook method for surveyor-using applications to override and provide the context object
     def render_context
       nil
     end
@@ -113,11 +159,14 @@ module Surveyor
       @current_user = self.respond_to?(:current_user) ? self.current_user : nil
     end
 
-    def set_render_context
+    def set_response_set_and_render_context
+      @response_set = ResponseSet.
+        find_by_access_code(params[:response_set_code], :include => {:responses => [:question, :answer]})
       @render_context = render_context
     end
 
-    # Params: the name of some submit buttons store the section we'd like to go to. for repeater questions, an anchor to the repeater group is also stored
+    # Params: the name of some submit buttons store the section we'd like to go
+    # to. for repeater questions, an anchor to the repeater group is also stored
     # e.g. params[:section] = {"1"=>{"question_group_1"=>"<= add row"}}
     def section_id_from(p)
       p.respond_to?(:keys) ? p.keys.first : p
@@ -145,10 +194,10 @@ module Surveyor
         end
       end
     end
-    
+
     ##
     # @dependents are necessary in case the client does not have javascript enabled
-    # Whether or not javascript is enabled is determined by a hidden field set in the surveyor/edit.html form 
+    # Whether or not javascript is enabled is determined by a hidden field set in the surveyor/edit.html form
     def set_dependents
       if session[:surveyor_javascript] && session[:surveyor_javascript] == "enabled"
         @dependents = []
@@ -156,11 +205,11 @@ module Surveyor
         @dependents = get_unanswered_dependencies_minus_section_questions
       end
     end
-    
+
     def get_unanswered_dependencies_minus_section_questions
       @response_set.unanswered_dependencies - @section.questions || []
     end
-    
+
     ##
     # If the hidden field surveyor_javascript_enabled is set to true
     # cf. surveyor/edit.html.haml
@@ -172,6 +221,6 @@ module Surveyor
         session[:surveyor_javascript] = "not_enabled"
       end
     end
-    
+
   end
-end
+end

data/lib/surveyor/version.rb

@@ -1,3 +1,3 @@
 module Surveyor
-  VERSION = '0.22.0'
-end
+  VERSION = '1.0.0'
+end

data/lib/surveyor.rb

@@ -1,14 +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 'formtastic/surveyor_builder'
 # require 'surveyor/surveyor_controller_methods'
 # require 'surveyor/models/survey_methods'
-Formtastic::SemanticFormHelper.builder = Formtastic::SurveyorBuilder
-Formtastic::SemanticFormBuilder.default_text_area_height = 5
-Formtastic::SemanticFormBuilder.default_text_area_width = 50
-Formtastic::SemanticFormBuilder.all_fields_required_by_default = false
+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

@@ -16,7 +16,7 @@ namespace :surveyor do
     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")
+    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"
@@ -37,7 +37,7 @@ namespace :surveyor do
         puts "not found"
       end
     else
-      puts "There are no surveys available"      
+      puts "There are no surveys available"
     end
   end
   desc "remove surveys (that don't have response sets)"
@@ -57,18 +57,30 @@ namespace :surveyor do
         put "not found"
       end
     else
-      puts "There are no surveys without response sets"      
+      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'
-    raise "USAGE: rake surveyor:dump SURVEY_ACCESS_CODE=<access_code> [OUTPUT_DIR=<dir>]" unless ENV["SURVEY_ACCESS_CODE"] 
-    survey = Survey.find_by_access_code(ENV["SURVEY_ACCESS_CODE"])
-    raise "No Survey found with code " + ENV["SURVEY_ACCESS_CODE"] unless survey
+    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}_#{Time.now.to_i}.csv")
+    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