ccls-surveyor 1.0.0

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/generators/test_surveyor/templates/environments/cucumber.rb

@@ -0,0 +1,21 @@
+config.cache_classes = true # This must be true for Cucumber to operate correctly!
+
+# Log error messages when you accidentally call methods on nil.
+config.whiny_nils = true
+
+# Show full error reports and disable caching
+config.action_controller.consider_all_requests_local = true
+config.action_controller.perform_caching             = false
+
+# Disable request forgery protection in test environment
+config.action_controller.allow_forgery_protection    = false
+
+# Tell Action Mailer not to deliver emails to the real world.
+# The :test delivery method accumulates sent emails in the
+# ActionMailer::Base.deliveries array.
+config.action_mailer.delivery_method = :test
+
+config.gem "cucumber",    :lib => false,        :version => ">=0.3.11" unless File.directory?(File.join(Rails.root, 'vendor/plugins/cucumber'))
+config.gem "webrat",      :lib => false,        :version => ">=0.4.4" unless File.directory?(File.join(Rails.root, 'vendor/plugins/webrat'))
+config.gem "rspec",       :lib => false,        :version => ">=1.2.6" unless File.directory?(File.join(Rails.root, 'vendor/plugins/rspec'))
+config.gem "rspec-rails", :lib => 'spec/rails', :version => ">=1.2.6" unless File.directory?(File.join(Rails.root, 'vendor/plugins/rspec-rails'))

data/generators/test_surveyor/test_surveyor_generator.rb

@@ -0,0 +1,15 @@
+class TestSurveyorGenerator < Rails::Generator::Base
+  def manifest
+    record do |m|
+      
+      m.directory "surveys"
+      
+      # Copy README to your app
+      m.file "TESTING_SURVEYOR", "surveys/TESTING_SURVEYOR"
+        
+      m.file "environments/cucumber.rb", "config/environments/cucumber.rb"
+      m.readme "TESTING_SURVEYOR"
+      
+    end
+  end
+end

data/lib/ccls-surveyor.rb

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

data/lib/fixtures_extensions.rb

@@ -0,0 +1,6 @@
+class Fixtures
+  def delete_existing_fixtures
+    # @connection.delete "DELETE FROM #{@connection.quote_table_name(table_name)}", 'Fixture Delete'
+    puts "Appending, skipping delete..."
+  end
+end

data/lib/surveyor.rb

@@ -0,0 +1,44 @@
+require File.dirname(__FILE__) + '/surveyor/acts_as_response'
+module Surveyor
+  RAND_CHARS = [('a'..'z'), ('A'..'Z'), (0..9)].map{|r| r.to_a}.flatten.to_s
+
+  def self.make_tiny_code(len = 10)
+    if RUBY_VERSION < "1.8.7"
+      (1..len).to_a.map{|i| RAND_CHARS[rand(RAND_CHARS.size), 1] }.to_s
+    else
+      len.times.map{|i| RAND_CHARS[rand(RAND_CHARS.size), 1] }.to_s
+    end
+  end
+
+  def self.to_normalized_string(text)
+    words_to_omit = %w(a be but has have in is it of on or the to when)
+    col_text = text.gsub(/(<[^>]*>)|\n|\t/s, ' ') # Remove html tags
+    col_text.downcase!                            # Remove capitalization
+    col_text.gsub!(/\"|\'/, '')                   # Remove potential problem characters
+    col_text.gsub!(/\(.*?\)/,'')                  # Remove text inside parens
+    col_text.gsub!(/\W/, ' ')                     # Remove all other non-word characters      
+    cols = (col_text.split(' ') - words_to_omit)
+    (cols.size > 5 ? cols[-5..-1] : cols).join("_")
+  end
+end
+
+# From http://guides.rubyonrails.org/plugins.html#controllers
+# Fix for:
+# ArgumentError in SurveyorController#edit 
+# A copy of ApplicationController has been removed from the module tree but is still active!
+# Equivalent of using "unloadable" in SurveyorController (unloadable has been deprecated)
+
+%w{models controllers}.each do |dir|
+  path = File.expand_path(File.join(File.dirname(__FILE__), '../app', dir))
+  # $LOAD_PATH << path # already here
+  # ActiveSupport::Dependencies.load_paths << path # already here too
+#  ActiveSupport::Dependencies.load_once_paths.delete(path)
+#  ActiveSupport::Dependencies.autoload_once_paths.delete(path)
+  # [$LOAD_PATH, ActiveSupport::Dependencies.load_paths, ActiveSupport::Dependencies.load_once_paths].each{|x| Rails.logger.info x}
+
+
+	ActiveSupport::Dependencies.autoload_paths << path
+	ActiveSupport::Dependencies.autoload_once_paths << path
+end
+
+require 'surveyor/config'

data/lib/surveyor/acts_as_response.rb

@@ -0,0 +1,33 @@
+require 'active_record'
+
+module Surveyor
+  module Response
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      def acts_as_response
+        include Surveyor::Response::InstanceMethods
+      end    
+    end
+    
+    module InstanceMethods
+      # Returns the response as a particular response_class type
+      def as(type_symbol)
+        return case type_symbol.to_sym
+        when :string, :text, :integer, :float, :datetime
+          self.send("#{type_symbol}_value".to_sym)
+        when :date
+          self.datetime_value.nil? ? nil : self.datetime_value.to_date
+        when :time
+          self.datetime_value.nil? ? nil : self.datetime_value.to_time
+        else # :answer_id
+          self.answer_id
+        end
+      end
+    end
+  end
+end
+
+ActiveRecord::Base.send(:include, Surveyor::Response)

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/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::Parser.parse(File.join(RAILS_ROOT, ENV["FILE"]))
+  end
+
+  desc "load survey fixtures"
+  task :load_fixtures => :environment do
+    require 'active_record/fixtures'
+    require 'fixtures_extensions' unless ENV["APPEND"].blank?
+    ActiveRecord::Base.establish_connection(Rails.env)
+
+    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/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/rails/init.rb

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

data/script/surveyor/answer.rb

@@ -0,0 +1,54 @@
+module SurveyParser
+  class Answer < SurveyParser::Base
+    # Context, Content, Reference, Display
+    attr_accessor :id, :parser, :question_id
+    attr_accessor :text, :short_text, :help_text, :weight, :response_class
+    attr_accessor :reference_identifier, :data_export_identifier, :common_namespace, :common_identitier
+    attr_accessor :display_order, :is_exclusive, :hide_label, :display_length, :custom_class, :custom_renderer
+    attr_accessor :validation
+
+    def default_options
+      { :is_exclusive => false,
+        :hide_label => false,
+        :response_class => "answer"
+      }
+    end
+  
+    def parse_args(args)
+      case args[0]
+      when Hash # Hash
+        text_args(args[0][:text]).merge(args[0])
+      when String # (String, Hash) or (String, Symbol, Hash)
+        text_args(args[0]).merge(hash_from args[1]).merge(args[2] || {})
+      when Symbol # (Symbol, Hash) or (Symbol, Symbol, Hash)
+        symbol_args(args[0]).merge(hash_from args[1]).merge(args[2] || {})
+      else
+        text_args(nil)
+      end
+    end
+  
+    def text_args(text = "Answer")
+      {:text => text.to_s, :short_text => text, :data_export_identifier => Surveyor.to_normalized_string(text)}
+    end
+    def hash_from(arg)
+      arg.is_a?(Symbol) ? {:response_class => arg.to_s} : arg.is_a?(Hash) ? arg : {}
+    end
+    def symbol_args(arg)
+      case arg
+      when :other
+        text_args("Other")
+      when :other_and_string
+        text_args("Other").merge({:response_class => "string"})
+      when :none, :omit # is_exclusive erases and disables other checkboxes and input elements
+        text_args(arg.to_s.humanize).merge({:is_exclusive => true})
+      when :integer, :date, :time, :datetime, :text, :datetime, :string
+        text_args(arg.to_s.humanize).merge({:response_class => arg.to_s, :hide_label => true})
+      end
+    end
+    def to_file
+      super
+      if self.validation then self.validation.to_file end
+    end
+  
+  end
+end

data/script/surveyor/base.rb

@@ -0,0 +1,77 @@
+module SurveyParser
+  class Base
+    
+    # Class level instance variable, because class variable are shared with subclasses
+    class << self
+      attr_accessor :children
+    end
+    
+    @children = []
+    
+    # Class methods
+    def self.inherited(subclass)
+      # set the class level instance variable default on subclasses
+      subclass.instance_variable_set(:@children, self.instance_variable_get(:@children))
+    end
+    
+    def self.has_children(*args)
+      args.each{|model| attr_accessor model}
+      self.instance_variable_set(:@children, args)
+    end
+    
+    # Instance methods
+    def initialize(obj, args, opts)
+      # inherit the parser from parent (obj)
+      self.parser = (obj.nil? ? nil : obj.class == SurveyParser::Parser ? obj : obj.parser)
+      # get a new id from the parser
+      self.id = parser.nil? ? nil : parser.send("new_#{self.class.name.demodulize.underscore}_id")
+      # set [parent]_id to obj.id, if we have that attribute
+      self.send("#{obj.class.name.demodulize.underscore}_id=", obj.nil? ? nil : obj.id) if self.respond_to?("#{obj.class.name.demodulize.underscore}_id=") 
+      # initialize descendant models
+      self.class.children.each{|model| self.send("#{model}=", [])}
+      # combine default options, parsed opts, parsed args, and initialize instance variables
+      self.default_options.merge(parse_opts(opts)).merge(parse_args(args)).each{|k,v| self.send("#{k.to_s}=", v)}
+      # print to the log
+      print "#{self.class.name.demodulize.gsub(/[a-z]/, "")[-1,1]}#{self.id} "
+    end
+    def default_options
+      {}
+    end
+    def parse_opts(opts)
+      opts.reject{|k,v| k == :method_name} # toss the method name by default
+    end
+    def parse_args(args)
+      args[0] || {}
+    end
+    
+    # Filter out attributes that shouldn't be in fixtures, including children, parser, placeholders
+    def yml_attrs
+      instance_variables.sort - self.class.children.map{|model| "@#{model.to_s}"} - %w(@id @parser @dependency @validation @question_reference @answer_reference)
+    end
+    def to_yml
+      out = [ %(#{self.parser.salt}_#{self.class.name.demodulize.underscore}_#{@id}:) ]
+      yml_attrs.each{|a| out << associate_and_format(a)}
+      (out << nil ).join("\r\n")
+    end
+    def associate_and_format(a)
+      if a =~ /_id$/ # a foreign key, e.g. survey_id
+        "  #{a[1..-4]}: " + (instance_variable_get(a).nil? ? "" : "#{self.parser.salt}_#{a[1..-4]}_#{instance_variable_get(a)}")
+      else # quote strings
+#
+#	>> Regexp.new( /[0-9a-zA-z\. #]/).to_s
+#	=> "(?-mix:[0-9a-zA-z\\. #])"
+#
+#	The regex in kitchen sink included a space which caused the yml 
+# to have a space which got chopped off in the fixture load leaving 
+# an open ended regex which ruby did not like at all.  Therefore, 
+# wrap Regexp in quotes as well?
+#
+        "  #{a[1..-1]}: #{(instance_variable_get(a).is_a?(String) || instance_variable_get(a).is_a?(Regexp)) ? "\"#{instance_variable_get(a)}\"" : instance_variable_get(a) }"
+      end
+    end
+    def to_file
+      File.open(self.parser.send("#{self.class.name.demodulize.underscore.pluralize}_yml"), File::CREAT|File::APPEND|File::WRONLY) {|f| f << to_yml}
+      self.class.children.each{|model| self.send(model).compact.map(&:to_file)}
+    end
+  end
+end

data/script/surveyor/dependency.rb

@@ -0,0 +1,13 @@
+module SurveyParser
+  class Dependency < SurveyParser::Base
+    # Context, Conditional, Children
+    attr_accessor :id, :question_id, :question_group_id, :parser
+    attr_accessor :rule
+    has_children :dependency_conditions
+
+    def parse_opts(opts)
+      {} # toss the method name and reference identifier by default
+    end
+
+  end
+end

data/script/surveyor/dependency_condition.rb

@@ -0,0 +1,40 @@
+module SurveyParser
+  class DependencyCondition < SurveyParser::Base
+
+    # 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
+  
+    def default_options
+      { :operator => "==" }
+    end
+    def parse_args(args)
+      a0, a1, a2 = args
+      {:question_reference => a0.to_s.gsub("q_", ""), :operator => a1}.merge(a2.is_a?(Hash) ? a2 : {:answer_reference => a2.to_s.gsub("a_", "")})
+    end
+    def parse_opts(opts)
+      {:rule_key => opts[:reference_identifier]}
+    end
+  
+    def reconcile_dependencies
+      # Looking up references to questions and answers for linking the dependency objects
+      print "Lookup Q ref #{@question_reference}:"
+      if (ref_question = parser.current_survey.find_question_by_reference(@question_reference))
+        print " found Q#{ref_question.id} "
+        @question_id = ref_question.id
+        print "Lookup A ref #{@answer_reference}"
+        if (ref_answer = ref_question.find_answer_by_reference(@answer_reference))
+          print " found A#{ref_answer.id} "
+          @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
+
+  end
+end

data/script/surveyor/parser.rb

@@ -0,0 +1,207 @@
+require 'active_support' # for pluralize, humanize in ActiveSupport::CoreExtensions::String::Inflections
+module SurveyParser
+  class Parser
+    @@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}"}
+
+    # Attributes
+    attr_accessor :salt, :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::Parser.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 self.define_counter_methods(names)
+      names.each do |name|
+        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.salt = Time.now.strftime("%Y%m%d%H%M%S")
+      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.
+    def initialize_fixtures(names, path)
+      names.each {|name| file = instance_variable_set("@#{name}_yml", "#{path}/#{name}.yml"); File.truncate(file, 0) if File.exist?(file) }
+    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)
+
+
+      # explicitly define a dependency condition
+      # (not really necessary as is default)
+      when "dependencycondition", "dcondition", "dc"
+        drop_the &block
+        raise "Error: No current dependency for this condition" if self.current_dependency.nil?
+        self.current_dependency.dependency_conditions << DependencyCondition.new(self.current_dependency, args, opts)
+
+      # explicitly define a validation condition
+      # (is necessary if want dependency AND validation on
+      #  same question as dependency existance would try to
+      #  make the condition a dependency condition.)
+      when "validationcondition", "vcondition", "vc"
+        drop_the &block
+        raise "Error: No current validation for this condition" if self.current_validation.nil?
+        self.current_validation.validation_conditions << ValidationCondition.new(self.current_validation, args, opts)
+      
+
+
+      else
+        raise "  ERROR: '#{missing_method}' 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)
+      "SurveyParser::#{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 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
+      self.surveys.compact.map(&:to_file)
+    end
+
+  end
+end