surveyor 0.8.0 → 0.9.0

data/script/surveyor/specs/spec_helper.rb

@@ -0,0 +1,6 @@
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..'))
+require File.expand_path(File.dirname(__FILE__) + "/../../../lib/surveyor")
+require File.expand_path(File.dirname(__FILE__) + "/../base")
+
+Spec::Runner.configure do |config|
+end

data/script/surveyor/specs/survey_section_spec.rb

@@ -0,0 +1,23 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+require 'survey_section'
+
+describe SurveySection, "when first created" do
+
+  before(:each) do
+    @section = SurveySection.new(mock("Survey", :id => 2, :parser => mock("Parser", :new_survey_section_id => 1)), ["Demographics"], {})
+  end
+  
+  it "should generate a data export identifier" do
+    @section.data_export_identifier.should == "demographics"
+  end
+  
+  it "should find a question by reference" do
+    @section.questions << mock("Question", :reference_identifier => "1", :text => "foo")
+    @section.questions << mock("Question", :reference_identifier => "2", :text => "foo")
+    @section.questions << mock("Question", :reference_identifier => "3", :text => "foo")
+    
+    q = @section.find_question_by_reference("2")
+    q.should_not be_nil
+    q.reference_identifier.should == "2"
+  end
+end

data/script/surveyor/specs/validation_condition_spec.rb

@@ -0,0 +1,20 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+require 'validation_condition'
+
+describe ValidationCondition, " when first created" do
+  before do    
+    validation = mock("Validation", :id => 29, :parser => mock("Parser", :new_validation_condition_id => 21))
+    validation.stub!(:class => Validation)
+    args = [">=", {:integer_value => 0}]
+    options = {}
+    @validation_condition = ValidationCondition.new(validation, args, options)
+  end
+  
+  it "should set initialization parameters properly" do
+    @validation_condition.id.should == 21
+    @validation_condition.validation_id.should == 29
+    @validation_condition.integer_value.should == 0
+    @validation_condition.operator.should == ">="
+  end
+
+end

data/script/surveyor/specs/validation_spec.rb

@@ -0,0 +1,20 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+require 'validation'
+
+describe Validation, " when first created" do
+  before do    
+    answer = mock("Answer", :id => 2, :parser => mock("Parser", :new_validation_id => 1))
+    answer.stub!(:class => Answer)
+    args = [{:rule => "C", :message => "Please select a number between 0 and 120"}]
+    options = {}
+    @validation = Validation.new(answer, args, options)
+  end
+  
+  it "should set initialization parameters properly" do
+    @validation.id.should == 1
+    @validation.message.should == "Please select a number between 0 and 120"
+    @validation.answer_id.should == 2
+    @validation.rule.should == "C"
+  end
+
+end

data/script/surveyor/survey.rb

@@ -1,85 +1,25 @@
-require File.dirname(__FILE__) + '/survey_section'
-
-class Survey
-  include Columnizer
-  # Context, Content, Reference, Expiry, Display, Children
+class Survey < SurveyParser::Base
+  # Context, Content, Reference, Expiry, Display
   attr_accessor :id, :parser
   attr_accessor :title, :description
   attr_accessor :access_code, :reference_identifier, :data_export_identifier, :common_namespace, :common_identitier
   attr_accessor :active_at, :inactive_at
   attr_accessor :css_url, :custom_class
-  attr_accessor :survey_sections
-  
-  @@current_survey = nil
-  
-  def self.current_survey
-    @@current_survey
-  end
-  
-  def self.current_survey=(value)
-    @@current_survey = value
-    puts "Assigning current survey #{@@current_survey.title}"
-  end
+  has_children :survey_sections
   
-  # id, parser, and title required
-  def initialize(id, parser, title, options = {})
-    self.id = id
-    self.parser = parser
-    self.title = title
-    self.survey_sections = []
-    self.access_code = Columnizer.to_normalized_column(title)
-    # self.default_options(title).merge(options).each{|key,value| self.instance_variable_set("@#{key}", value)}
-    Survey.current_survey = self
+  def parse_args(args)
+    title = args[0]
+    {:title => title, :access_code => Surveyor.to_normalized_string(title)}.merge(args[1] || {})
   end
-  
-  # def default_options(title)
-  #   {}
-  # end
 
-  # This method_missing magic does all the heavy lifting for the DSL
-  def method_missing(missing_method, *args, &block)
-    m_name = missing_method.to_s
-    if (section_match = m_name.match(/(\Asection)_?(.*)/))
-      build_survey_section(section_match[3].to_s, *args, &block) # Parse "section" method, create new section in this survey
-    else
-      puts "  ERROR: '#{m_name}' not valid method_missing name"
-    end
-  end
-  
-  def build_survey_section(reference_identifier, title, &block)
-    puts "  Section: #{title}"
-    if block_given?
-      new_survey_section = SurveySection.new(new_survey_section_id, self, title, {:display_order => self.survey_sections.size + 1, :reference_identifier => reference_identifier})
-      new_survey_section.instance_eval(&block)
-      add_survey_section(new_survey_section)
-      puts "  Section added"
-    else
-      puts "  ERROR: A section cannot be empty!"
-    end
-  end
-  
-  def new_survey_section_id
-    self.parser.new_survey_section_id
-  end
-  
-  def add_survey_section(survey_section)
-    self.survey_sections << survey_section
-  end
- 
-  # Used to find questions for dependency linking
   def find_question_by_reference(ref_id)
-    question = nil
-    count = 0
-    while question.nil? and count < self.survey_sections.size
-      question = self.survey_sections[count].find_question_by_reference(ref_id)
-      count += 1
-    end
-    question
+    found = nil
+    survey_sections.detect{|s| found = s.find_question_by_reference(ref_id)}
+    return found
   end
   
-  
   def reconcile_dependencies
-    @survey_sections.each do |section|
+    survey_sections.each do |section|
       section.questions.each do |question| 
         question.dependency.dependency_conditions.each { |con| con.reconcile_dependencies} unless question.dependency.nil?
       end
@@ -89,19 +29,4 @@ class Survey
     end  
   end
 
-  def yml_attrs
-    instance_variables.sort - ["@parser", "@survey_sections"]
-  end
-  def to_yml
-    out = [ %(survey_#{@id}:) ]
-    yml_attrs.each{|a| out << "  #{a[1..-1]}: #{instance_variable_get(a).is_a?(String) ? "\"#{instance_variable_get(a)}\"" : instance_variable_get(a) }"}
-    (out << nil ).join("\r\n")
-  end
-
-  def to_file
-    "survey -#{self.title}- written to file..."
-    File.open(self.parser.surveys_yml, File::CREAT|File::APPEND|File::WRONLY) {|f| f << to_yml}
-    self.survey_sections.compact.map(&:to_file)
-  end
- 
 end

data/script/surveyor/survey_parser.rb

@@ -1,60 +1,182 @@
-require File.dirname(__FILE__) + '/survey'
+require 'activesupport' # for pluralize, humanize in ActiveSupport::CoreExtensions::String::Inflections
 
 class SurveyParser
-  # Children, Counters, Files
-  attr_accessor :surveys
-  attr_accessor :last_survey_id, :last_survey_section_id, :last_question_id, :last_answer_id
-  attr_accessor :surveys_yml, :survey_sections_yml, :question_groups_yml, :questions_yml, :answers_yml, :dependencies_yml, :dependency_conditions_yml
+  @@models = %w(survey survey_section question_group question answer dependency dependency_condition validation validation_condition)
+  
+  # Require base and all models
+  (%w(base) + @@models).each{|m| require File.dirname(__FILE__) + "/#{m}"}
 
-  # no more "ARRRGH, EVIL GLOBALS!!!"
-  def initialize
-    self.surveys = []
-    self.define_counter_methods(%w(survey survey_section question_group question answer dependency dependency_condition))
-    self.initialize_fixtures(%w(surveys survey_sections question_groups questions answers dependencies dependency_conditions), File.join(RAILS_ROOT, "surveys", "fixtures"))
+  # Attributes
+  attr_accessor :surveys, :grid_answers
+  @@models.each{|m| attr_accessor "#{m.pluralize}_yml".to_sym } # for fixtures
+  (@@models - %w(dependency_condition validation_condition)).each {|m| attr_accessor "current_#{m}".to_sym} # for current_model caches
+  
+  # Class methods
+  def self.parse(file_name)
+    self.define_counter_methods(@@models)
+    puts "\n--- Parsing '#{file_name}' ---"
+    parser = SurveyParser.new
+    parser.instance_eval(File.read(file_name))
+    parser.to_files
+    puts "--- End of parsing ---\n\n"
   end
 
   # new_survey_id, new_survey_section_id, etc.
-  def define_counter_methods(names)
+  def self.define_counter_methods(names)
     names.each do |name|
-      self.instance_variable_set("@last_#{name}_id", 0)
-      # self.class.send is a hack - define_method is private
-      self.class.send(:define_method, "new_#{name}_id") do
-        self.instance_variable_set("@last_#{name}_id", self.instance_variable_get("@last_#{name}_id") + 1)
+      define_method("new_#{name}_id") do
+        instance_variable_set("@last_#{name}_id", instance_variable_get("@last_#{name}_id") + 1)
       end
     end
   end
+  
+  # Instance methods
+  def initialize
+    self.surveys = []
+    self.grid_answers = []
+    initialize_counters(@@models)
+    initialize_fixtures(@@models.map(&:pluralize), File.join(RAILS_ROOT, "surveys", "fixtures"))
+  end
+  
+  # @last_survey_id, @last_survey_section_id, etc.
+  def initialize_counters(names)
+    names.each{|name| instance_variable_set("@last_#{name}_id", 0)}
+  end
 
-  # surveys_yml, survey_sections_yml, etc.
+  # @surveys_yml, @survey_sections_yml, etc.
   def initialize_fixtures(names, path)
-    names.each do |name|
-      file = self.instance_variable_set("@#{name}_yml", "#{path}/#{name}.yml")
-      File.truncate(file, 0) if File.exist?(file)
-    end
+    names.each {|name| file = instance_variable_set("@#{name}_yml", "#{path}/#{name}.yml"); File.truncate(file, 0) if File.exist?(file) }
   end
 
-  def self.parse(file_name)
-    puts "--- Parsing '#{file_name}' ---"
-    parser = SurveyParser.new
-    parser.instance_eval(File.read(file_name), file_name)
-    parser.to_files
-    puts "--- End of parsing ---"
-  end
+  # This method_missing does all the heavy lifting for the DSL
+  def method_missing(missing_method, *args, &block)
+    method_name, reference_identifier = missing_method.to_s.split("_", 2)
+    opts = {:method_name => method_name, :reference_identifier => reference_identifier}
+    case method_name
+    when "survey"
+      self.current_survey = Survey.new(self, args, opts)
+      evaluate_the "survey", &block
+    
+    when "section"
+      self.current_survey_section = SurveySection.new(self.current_survey, args, opts.merge({:display_order => current_survey.survey_sections.size + 1}))
+      evaluate_the "survey_section", &block
+      
+    when "group", "g", "grid", "repeater"
+      self.current_question_group = QuestionGroup.new(self.current_survey_section, args, opts)
+      evaluate_the "question_group", &block
+      
+    when "question", "q", "label", "image"
+      drop_the &block
+      self.current_question = Question.new(self.current_survey_section, args, opts.merge(:question_group_id => current_question_group ? current_question_group.id : nil))
+      add_grid_answers if in_a_grid?
+      
+    when "dependency", "d"
+      drop_the &block
+      self.current_dependency = Dependency.new(self.current_question_group || current_question, args, opts)
+      
+    when "condition", "c"
+      drop_the &block
+      raise "Error: No current dependency or validation for this condition" if self.current_dependency.nil? && self.current_validation.nil?
+      if self.current_dependency.nil?
+        self.current_validation.validation_conditions << ValidationCondition.new(self.current_validation, args, opts)
+      else
+        self.current_dependency.dependency_conditions << DependencyCondition.new(self.current_dependency, args, opts)
+      end
+      
+    when "answer", "a"
+      drop_the &block
+      if in_a_grid?
+        self.grid_answers << Answer.new(nil, args, opts.merge(:display_order => grid_answers.size + 1))
+      else
+        raise "Error: No current question" if self.current_question.nil?
+        self.current_answer = Answer.new(self.current_question, args, opts.merge(:display_order => current_question.answers.size + 1))
+      end
+    
+    when "validation", "v"
+      drop_the &block
+      self.current_validation = Validation.new(self.current_answer, args, opts)
 
-  def survey(title, &block)
-    puts "Survey: #{title}"
-    if block_given?
-      new_survey = Survey.new(self.new_survey_id, self, title)
-      new_survey.instance_eval(&block)    
-      new_survey.reconcile_dependencies
-      add_survey(new_survey)
-      puts "Survey added"
     else
-      puts "ERROR: A survey cannot be empty!"
+      raise "  ERROR: '#{method_name}' not valid method"
+    
+    end
+  end
+
+  def drop_the(&block)
+    raise "Error, I'm dropping the block like it's hot" if block_given?
+  end
+  
+  def evaluate_the(model, &block)
+    raise "Error: A #{model.humanize} cannot be empty" unless block_given?
+    self.instance_eval(&block)
+    self.send("clear_current", model)
+  end
+  
+  def clear_current(model)
+    # puts "clear_current #{model}"
+    case model
+    when "survey"
+      self.current_survey.reconcile_dependencies unless current_survey.nil?
+    when "question_group"
+      self.grid_answers = []
+      clear_current("question")
+    when "question"
+      @current_dependency = nil
+    when "answer"
+      @current_validation = nil
     end
+    instance_variable_set("@current_#{model}", nil)
+    model.classify.constantize.send(:children).each{|m| clear_current(m.to_s.singularize)}
+  end
+  
+  def current_survey=(s)
+    clear_current "survey"
+    self.surveys << s
+    @current_survey = s
+  end
+  def current_survey_section=(s)
+    clear_current "survey_section"
+    self.current_survey.survey_sections << s
+    @current_survey_section = s 
+  end
+  def current_question_group=(g)
+    clear_current "question_group"
+    self.current_survey_section.question_groups << g
+    @current_question_group = g
+  end  
+  def current_question=(q)
+    clear_current "question"
+    self.current_survey_section.questions << q
+    @current_question = q
+  end
+  def current_dependency=(d)
+    raise "Error: No question or question group" unless (dependent = self.current_question_group || self.current_question)
+    dependent.dependency = d
+    @current_dependency = d
+  end
+  def current_answer=(a)
+    raise "Error: No current question" if self.current_question.nil?
+    self.current_question.answers << a
+    @current_answer = a
+  end  
+  def current_validation=(v)
+    clear_current "validation"
+    self.current_answer.validation = v
+    @current_validation = v
   end
 
-  def add_survey(survey)
-    self.surveys << survey
+  def in_a_grid?
+    self.current_question_group and self.current_question_group.display_type == "grid"
+  end
+  
+  def add_grid_answers
+    self.grid_answers.each do |grid_answer|
+      my_answer = grid_answer.dup
+      my_answer.id = new_answer_id
+      my_answer.question_id = self.current_question.id
+      my_answer.parser = self
+      self.current_answer = my_answer
+    end
   end
 
   def to_files

data/script/surveyor/survey_section.rb

@@ -1,143 +1,19 @@
-require File.dirname(__FILE__) + '/question_group'
-require File.dirname(__FILE__) + '/question'
-require File.dirname(__FILE__) + '/answer'
-require File.dirname(__FILE__) + '/dependency'
-require File.dirname(__FILE__) + '/dependency_condition'
-require File.dirname(__FILE__) + '/columnizer'
-require 'activesupport'
-#require 'activesupport/lib/active_support/core_ext/string/inflections'
-
-class SurveySection
-  include Columnizer
-
+class SurveySection < SurveyParser::Base
   # Context, Content, Display, Reference, Children, Placeholders
   attr_accessor :id, :parser, :survey_id
   attr_accessor :title, :description
   attr_accessor :reference_identifier, :data_export_identifier, :common_namespace, :common_identitier
   attr_accessor :display_order, :custom_class
-  attr_accessor :question_groups, :questions, :grid_answers
-  attr_accessor :current_question_group, :current_question, :current_dependency
+  has_children :question_groups, :questions
 
-  # id, survey, and title required
-  def initialize(id, survey, title, options = {})
-    self.id = id
-    self.survey_id = survey.id
-    self.parser = survey.parser
-    self.title = title.strip
-    self.questions = []
-    self.question_groups = []
-    self.grid_answers = []
-    self.current_question_group = nil
-    self.current_question = nil
-    self.current_dependency = nil
-    self.default_options(title).merge(options).each{|key,value| self.instance_variable_set("@#{key}", value)}
+  def parse_args(args)
+    title = args[0]
+    {:title => title, :data_export_identifier => Surveyor.to_normalized_string(title)}.merge(args[1] || {})
   end
 
-  def default_options(title)
-    { :data_export_identifier => Columnizer.to_normalized_column(title)
-    }
-  end
-
-  # This method_missing magic does all the heavy lifting for the DSL
-  def method_missing(missing_method, *args, &block)    
-    method_name, reference_identifier = missing_method.to_s.split("_")
-    
-    case method_name
-      
-    when "group", "g", "grid", "repeater"
-      puts "    Group: #{reference_identifier}"
-      raise "Error: A question group cannot be empty" unless block_given?
-      
-      clear_current_question
-      options = {:reference_identifier => reference_identifier, :display_type => (method_name =~ /grid|repeater/)? method_name : nil }
-      self.question_groups << (self.current_question_group = QuestionGroup.new(self, args, options))
-      self.instance_eval(&block)
-      clear_current_question_group
-      
-    when "question", "q", "label", "image"
-      puts "      Question: #{reference_identifier}"
-      raise "Error: I'm dropping the block like it's hot" if block_given?
-      
-      clear_current_question
-      options = {:reference_identifier => reference_identifier, :question_group_id => (current_question_group ? current_question_group.id : nil)}
-      options.merge!({:display_type => "label"}) if method_name == "label"
-      options.merge!({:display_type => "image"}) if method_name == "image"
-      self.questions << (self.current_question = Question.new(self, args, options))
-      add_grid_answers if self.current_question_group and self.current_question_group.display_type == "grid"
-      
-    when "dependency", "d"
-      puts "        Dependency: #{reference_identifier}"
-      raise "Error: I'm dropping the block like it's hot" if block_given?
-      raise "Error: No question or question group" unless (d = self.current_question_group || self.current_question)
-      
-      options = {}# {:reference_identifier => reference_identifier}
-      d.dependency = (self.current_dependency = Dependency.new(d, args, options))
-      
-    when "condition", "c"
-      puts "          Condition: #{reference_identifier}"
-      raise "Error, I'm dropping the block like it's hot" if block_given?
-      raise "Error: No current dependency" unless self.current_dependency
-      
-      options = {:rule_key => reference_identifier}
-      self.current_dependency.add_dependency_condition DependencyCondition.new(self, args, options)
-      
-    when "answer", "a"
-      puts "        Answer: #{reference_identifier}"
-      raise "Error, I'm dropping the block like it's hot" if block_given?
-      
-      if self.current_question_group and self.current_question_group.display_type == "grid"
-        options = {:reference_identifier => reference_identifier, :display_order => self.grid_answers.size + 1}
-        self.grid_answers << Answer.new(nil, args, options)
-      else
-        raise "Error: No current question" unless self.current_question
-        options = {:reference_identifier => reference_identifier, :display_order => self.current_question.answers.size + 1}
-        self.current_question.answers << Answer.new(self.current_question, args, options)
-      end
-      
-    else
-      raise "  ERROR: '#{m_name}' not valid method_missing name"
-    end
-  end
-
-  def clear_current_question_group
-    self.current_question_group = nil
-    self.grid_answers = []
-    self.current_question = nil
-  end
-
-  def clear_current_question
-    self.current_question = nil
-    self.current_dependency = nil
-  end
-
-  def add_grid_answers
-    self.grid_answers.each do |grid_answer|
-      my_answer = grid_answer.dup
-      my_answer.id = self.parser.new_answer_id
-      my_answer.question_id = self.current_question.id
-      my_answer.parser = self.parser
-      self.current_question.answers << my_answer
-    end
-  end
-  
-  # Used to find questions for dependency linking 
+  # Used to find questions for dependency linking
   def find_question_by_reference(ref_id)
     self.questions.detect{|q| q.reference_identifier == ref_id}
   end
   
-  def yml_attrs
-    instance_variables.sort - ["@parser", "@question_groups", "@questions", "@grid_answers", "@current_question_group", "@current_question", "@current_dependency"]
-  end
-  def to_yml
-    out = [ %(#{@data_export_identifier}_#{@id}:) ]
-    yml_attrs.each{|a| out << "  #{a[1..-1]}: #{instance_variable_get(a).is_a?(String) ? "\"#{instance_variable_get(a)}\"" : instance_variable_get(a) }"}
-    (out << nil ).join("\r\n")
-  end
-
-  def to_file
-    File.open(self.parser.survey_sections_yml, File::CREAT|File::APPEND|File::WRONLY) {|f| f << to_yml}
-    self.question_groups.compact.map(&:to_file)
-    self.questions.compact.map(&:to_file)
-  end
-
 end