surveyor 0.6.1

data/generators/surveyor/templates/tasks/surveyor.rb

@@ -0,0 +1,4 @@
+$VERBOSE = nil
+if surveyor_gem = Gem.searcher.find('surveyor')
+  Dir["#{surveyor_gem.full_gem_path}/lib/tasks/*.rake"].each { |ext| load ext }
+end

data/init.rb

@@ -0,0 +1 @@
+# Init hook code here

data/install.rb

@@ -0,0 +1 @@
+# Install hook code here

data/lib/surveyor.rb

@@ -0,0 +1,7 @@
+dir = File.dirname(__FILE__)
+$LOAD_PATH.unshift dir unless $LOAD_PATH.include?(dir)
+
+require 'surveyor/config'
+
+module Surveyor
+end

data/lib/surveyor/config.rb

@@ -0,0 +1,45 @@
+module Surveyor
+  #
+  # The Surveyor::Config object emulates a hash with simple bracket methods
+  # which allow you to get and set values in the configuration table:
+  #
+  #   Surveyor::Config['setting.name'] = 'value'
+  #   Surveyor::Config['setting.name'] #=> "value"
+  #
+  # Currently, there is not a way to edit configuration through the admin
+  # system so it must be done manually. The console script is probably the
+  # easiest way to this:
+  #
+  #   % script/console production
+  #   Loading production environment.
+  #   >> Surveyor::Config['setting.name'] = 'value'
+  #   => "value"
+  #   >>
+  #
+  # Surveyor currently uses the following settings:
+  #
+  # defaults.title               :: the title of the survey system
+  # defaults.layout              :: the layout used by the survey system
+
+  class Config
+    @@config_hash = {}
+
+    class << self
+      def [](key)
+        @@config_hash[key]
+      end
+
+      def []=(key, value)
+        @@config_hash[key] = value
+      end
+
+      def to_hash
+        @@config_hash
+      end
+      
+      def run
+        yield self if block_given?
+      end
+    end
+  end
+end

data/lib/tasks/surveyor_tasks.rake

@@ -0,0 +1,33 @@
+desc "generate and load survey (specify FILE=surveys/your_survey.rb)"
+task :surveyor => :"surveyor:default"
+
+namespace :surveyor do
+  
+  task :default => [:generate_fixtures, :load_fixtures]
+  
+  desc "generate survey fixtures from survey file"
+  task :generate_fixtures => :environment do
+    require File.join(File.dirname(__FILE__), "../../script/surveyor/survey_parser")
+    raise "USAGE: file name required e.g. 'FILE=surveys/kitchen_sink_survey.rb'" if ENV["FILE"].blank?
+    fixture_dir = File.join(RAILS_ROOT, "surveys", "fixtures")
+    mkdir fixture_dir unless File.exists?(fixture_dir)
+    SurveyParser.parse(File.join(RAILS_ROOT, ENV["FILE"]))
+  end
+
+  desc "load survey fixtures"
+  task :load_fixtures => :environment do
+    require 'active_record/fixtures'
+    
+    ActiveRecord::Base.establish_connection(RAILS_ENV.to_sym)
+
+    fixture_dir = File.join(RAILS_ROOT, "surveys", "fixtures")
+    fixtures = Dir.glob("#{fixture_dir}/*.yml")
+    raise "No fixtures found." if fixtures.empty?
+    
+    fixtures.each do |file_name|
+      puts "Loading #{file_name}..."
+      Fixtures.create_fixtures(fixture_dir, File.basename(file_name, '.*'))
+    end
+  end
+
+end

data/lib/tiny_code.rb

@@ -0,0 +1,58 @@
+module TinyCode
+
+  module ClassMethods
+
+    RAND_CHARS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ" + "0123456789" + "abcdefghijklmnopqrstuvwxyz"
+
+    def make_tiny_code
+      random_string(10)
+    end
+
+    def random_string(len)
+      rand_max = RAND_CHARS.size
+      ret = "" 
+      len.times{ ret << RAND_CHARS[rand(rand_max)] }
+      ret 
+    end
+
+
+    def self.to_normalized_string(text)
+      words_to_omit = ["a", "to", "the", "of", "has", "have", "it", "is", "in", "on", "or", "but", "when", "be"]
+
+      # strip all the html tags from the text data
+      col_text = text.gsub(/(<[^>]*>)|\n|\t/s, ' ')
+
+      # Removing capitalization
+      col_text.downcase!
+      # Removing potential problem characters
+      col_text.gsub!(/\"|\'/, '')
+      # Removing text inside parens
+      col_text.gsub!(/\(.*?\)/,'')
+
+      # Removing all other non-word characters
+      col_text.gsub!(/\W/, ' ')
+
+      column_words = []
+      words = col_text.split(' ')
+      words.each do |word|
+        if !words_to_omit.include?(word)
+          column_words << word
+        end
+      end
+
+      #reducing the word list to limit column length
+      if column_words.length > 5
+        column_words.slice!(0, column_words.length - 5)
+      end
+
+      #re-assemble the string
+      column_words.join("_")
+    end 
+
+  end
+
+  def self.included(klass)
+    klass.extend(ClassMethods)
+  end
+
+end

data/lib/xml_formatter.rb

@@ -0,0 +1,12 @@
+module XmlFormatter
+  def to_xml(options = {})
+    options[:indent] ||= 2
+    xml = options[:builder] ||= Builder::XmlMarkup.new(:indent => options[:indent])
+    xml.instruct! unless options[:skip_instruct]
+    xml.tag!(self.class.name.downcase.to_sym, self.attributes) do
+      self.class.reflect_on_all_associations.to_a.each do |assoc|
+        xml.tag!(assoc.name)
+      end
+    end
+  end
+end

data/script/surveyor/answer.rb

@@ -0,0 +1,84 @@
+require File.dirname(__FILE__) + '/columnizer'
+
+class Answer  
+  include Columnizer
+
+  # Context, Content, Display, Reference
+  attr_accessor :id, :question_id, :parser
+  attr_accessor :text, :short_text, :help_text, :numerical_value
+  attr_accessor :response_class, :display_order, :is_exclusive, :is_a_disabler, :hide_label
+  attr_accessor :reference_identifier, :data_export_identifier
+  
+  def initialize(question, args, options)
+    self.parser = question ? question.parser : nil
+    self.id = parser ? parser.new_answer_id : nil
+    self.question_id = question ? question.id : nil
+
+    #self.text is set in args
+    args_options = parse_args_options(args)
+    self.default_options(args_options[:text]).merge(options).merge(args_options).each{|key,value| self.instance_variable_set("@#{key}", value)}
+  end
+  
+  def default_options(text)
+    { :short_text => text,
+      :data_export_identifier => Columnizer.to_normalized_column(text),
+      :is_exclusive => false,
+      :is_a_disabler => false,
+      :hide_label => false,
+      :response_class => "answer"
+    }
+  end
+  
+  def parse_args_options(args)
+    a0, a1, a2 = args
+    
+    # Hash
+    if a0.is_a?(Hash)
+      {:text => "Answer"}.merge(a0)
+      
+    # String, Hash || String, Symbol, Hash
+    elsif a0.is_a?(String)
+      a1.is_a?(Symbol) ? {:text => a0, :response_class => a1.to_s}.merge(a2 || {}) : {:text => a0}.merge(a1 || {})
+      
+    # Symbol, Hash || Symbol, Symbol, Hash
+    elsif a0.is_a?(Symbol)
+      shortcuts = case a0
+      when :other
+        {:text => "Other"}
+      when :other_and_string
+        {:text => "Other", :response_class => "string"}
+      when :none, :omit #a disabler erases and disables all other answer options (text, checkbox, dropdowns, etc). Unchecking the omit box is the only way to enable other options (except in the case limit => :one)
+        {:text => a0.to_s.humanize, :is_exclusive => true} # "omit" is no longer a response class... it's treated as any other answer type 
+      when :integer, :date, :time, :datetime, :text, :datetime, :string
+        {:text => a0.to_s.humanize, :response_class => a0.to_s, :hide_label => true}
+      else
+        {:text => a0.to_s.humanize}
+      end
+      a1.is_a?(Symbol) ? shortcuts.merge({:response_class => a1.to_s}).merge(a2 || {}) : shortcuts.merge(a1 || {})
+    else
+      {:text => "Answer"}
+    end
+  end
+
+  def to_yml
+    out =[ %(#{@data_export_identifier}_#{@id}:) ]
+    out << %(  id: #{@id})
+    out << %(  question_id: #{@question_id})
+    out << %(  text: "#{@text}")
+    out << %(  short_text: "#{@short_text}")
+    out << %(  help_text: "#{@help_text}")
+    out << %(  weight: #{@weight})
+    out << %(  response_class: "#{@response_class}")
+    out << %(  display_order: #{display_order} )
+    out << %(  is_exclusive: #{@is_exclusive})
+    out << %(  hide_label: #{@hide_label})
+    out << %(  reference_identifier: #{@reference_identifier})
+    out << %(  data_export_identifier: "#{@data_export_identifier}")
+    (out << nil ).join("\r\n")
+  end
+
+  def to_file
+     File.open(self.parser.answers_yml, File::CREAT|File::APPEND|File::WRONLY){ |f| f << to_yml }
+  end
+  
+end

data/script/surveyor/columnizer.rb

@@ -0,0 +1,36 @@
+module Columnizer
+   
+   def self.to_normalized_column(text)
+      words_to_omit = ["a", "to", "the", "of", "has", "have", "it", "is", "in", "on", "or", "but", "when", "be"]
+      
+      # strip all the html tags from the text data
+      col_text = text.gsub(/(<[^>]*>)|\n|\t/s, ' ')
+      
+      # Removing capitalization
+      col_text.downcase!
+      # Removing potential problem characters
+      col_text.gsub!(/\"|\'/, '')
+      # Removing text inside parens
+      col_text.gsub!(/\(.*?\)/,'')
+      
+      # Removing all other non-word characters
+      col_text.gsub!(/\W/, ' ')
+      
+      column_words = []
+      words = col_text.split(' ')
+      words.each do |word|
+         if !words_to_omit.include?(word)
+             column_words << word
+         end
+      end
+      
+      #reducing the word list to limit column length
+      if column_words.length > 5
+          column_words.slice!(0, column_words.length - 5)
+      end
+      
+      #re-assemble the string
+      column_words.join("_")
+   end 
+    
+end

data/script/surveyor/dependency.rb

@@ -0,0 +1,43 @@
+class Dependency
+  
+  # Context, Conditional, Children
+  attr_accessor :id, :question_id, :parser
+  attr_accessor :rule
+  attr_accessor :dependency_conditions
+
+  # id, question, and rule required
+  def initialize(question, args, options)
+    self.parser = question.parser
+    self.id = parser.new_dependency_id
+    self.question_id = question.id
+    self.rule = (args[0] || {})[:rule]
+    self.dependency_conditions = []
+    self.default_options().merge(options).merge(args[1] || {}).each{|key,value| self.instance_variable_set("@#{key}", value)}
+  end
+  
+  def default_options()
+    {}
+  end
+  
+  # Injecting the id of the current dependency object into the dependency_condition on assignment
+  def add_dependency_condition(dc_obj)
+    dc_obj.dependency_id = self.id
+    self.dependency_conditions << dc_obj
+  end
+  
+  def to_yml
+    out =[ %(#{question_id}_#{@id}:) ]
+    out << %(  id: #{@id})
+    out << %(  question_id: #{@question_id})
+    out << %(  rule: "#{@rule}")
+    (out << nil ).join("\r\n")
+  end
+
+  def to_file
+    File.open(self.parser.dependencies_yml, File::CREAT|File::APPEND|File::WRONLY) {|f| f << to_yml}
+    self.dependency_conditions.compact.map(&:to_file)  
+  end
+  
+  
+
+end

data/script/surveyor/dependency_condition.rb

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

data/script/surveyor/question.rb

@@ -0,0 +1,76 @@
+require File.dirname(__FILE__) + '/columnizer'
+
+class Question
+  include Columnizer
+  
+  # Context, Content, Display, Reference, Children
+  attr_accessor :id, :survey_section_id, :parser
+  attr_accessor :text, :short_text, :help_text
+  attr_accessor :pick, :display_type, :display_order, :question_group_id, :is_mandatory
+  attr_accessor :reference_identifier, :data_export_identifier
+  attr_accessor :answers, :dependency
+
+  def initialize(section, args, options)
+    self.parser = section.parser
+    self.id = parser.new_question_id
+    self.display_order = self.id
+    self.survey_section_id = section.id
+    self.text = args[0]
+    self.answers = []
+    self.dependency = nil
+    self.default_options(text).merge(options).merge(args[1] || {}).each{|key,value| self.instance_variable_set("@#{key}", value)}
+  end
+  
+  def default_options(text)
+    { :short_text => text,
+      :pick => :none,
+      :display_type => :default,
+      :is_mandatory => true,
+      :data_export_identifier => Columnizer.to_normalized_column(text)
+    }
+  end
+  
+  # Injecting the id of this question object into the dependency object on assignment
+  def dependency=(dep)
+    unless dep.nil?
+      dep.question_id = self.id
+    end
+    @dependency = dep
+  end
+  
+  def find_answer_by_reference(ref_id)
+    answer = nil
+    count = 0
+    puts "Looking up answer with ref: #{ref_id}"
+    while answer.nil? and count < self.answers.size
+      answer = self.answers[count] if self.answers[count].reference_identifier == ref_id
+      count += 1
+    end
+    puts "  found answer: '#{answer.text}' (id:#{answer.id})"  unless answer.nil?
+    answer
+  end
+
+  def to_yml
+    out =[ %(#{@data_export_identifier}_#{@id}:) ]
+    out << %(  id: #{@id})
+    out << %(  survey_section_id: #{@survey_section_id})
+    out << %(  text: "#{@text}")
+    out << %(  short_text: "#{@short_text}")
+    out << %(  help_text: "#{@help_text}")
+    out << %(  pick: #{pick})
+    out << %(  display_type: #{display_type})
+    out << %(  display_order: #{display_order})
+    out << %(  question_group_id: #{question_group_id})
+    out << %(  is_mandatory: #{@is_mandatory})
+    out << %(  reference_identifier: #{@reference_identifier})
+    out << %(  data_export_identifier: "#{@data_export_identifier}")
+    (out << nil ).join("\r\n")
+  end
+  
+  def to_file
+    File.open(self.parser.questions_yml, File::CREAT|File::APPEND|File::WRONLY){ |f| f << to_yml }
+    self.answers.compact.map(&:to_file)
+    if self.dependency then self.dependency.to_file end
+  end
+
+end